/* DataBaseManager es el manejador de base de datos
 * del proyecto SIGPIO. Su funcionalidad es recibir
 * objetos y ejecutar metodos sobre la base de datos
 */
package DBMS;

import clases.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.logging.Level;
import java.util.logging.Logger;
import pio.action.Printer;

/**
 * @author GreenCode
 * @since 1.0
 */
public class DataBaseManager {

    static private Connection conexion;

    protected DataBaseManager() {
    }
    static private DataBaseManager instance = null;

    static public DataBaseManager getInstance() {
        if (null == DataBaseManager.instance) {
            DataBaseManager.instance = new DataBaseManager();
        }
        conectar();
        return DataBaseManager.instance;
    }

    //Seccion de metodos publicos
    /**
     * Metodo de conexion a la base de datos metodo void no recibe parametros
     * solo ejecuta una conexion, puede lanzar una excepcion dependiendo del
     * estado del puerto
     */
    public static boolean conectar() {
        try {
            Class.forName("org.postgresql.Driver");
            conexion = DriverManager.getConnection(
                    "jdbc:postgresql://localhost:5432/postgres",
                    "postgres",
                    "postgres");
            return true;
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return false;
    }

    /**
     * Metodo para obtener el rol de un estudiante esta numerado segun la
     * funcion del participante dentro del
     *
     * @param registro usuario para obtener rol
     * @return rol que representa el tipo de estudiante
     */
    public int validar(Registro registro) throws SQLException, Exception {
        int rol = obtenerRol(registro);
        switch (rol) {
            case -1:
                return 999;
            default:
                return rol;
        }
    }

    /**
     * Metodo para agregar un usuario a la base de datos recibe el objeto a
     * agregar y lo intenta agregar a la base de datos
     *
     * @param Usuario u que representa el usuario a agregar
     * @return True si puede agregarlo false en otros casos
     */
    public boolean agregarUsuario(Usuario u) {
        System.out.println("agregarUsuario(" + u + ")");
        int agregados = 0;
        int validado = 0;
        if (!u.hasValidAtts()) {
            System.out.println("Atributos invalidos");
            return false;
        } else {
            System.out.println("Atributos validos");
        }
        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
            }
            String sqlquery = "INSERT INTO \"PIO\".usuario ("
                    + "cedula, nombres, apellidos"
                    + ", correo , sexo , telefonocasa , telefonocelular"
                    + " , direccion , fechanacimiento, nacionalidad ) "
                    + "VALUES ('" + u.getCedula()
                    + "','" + u.getNombres()
                    + "','" + u.getApellidos()
                    + "','" + (u.getCorreo() == null ? "" : u.getCorreo())
                    + "','" + (u.getSexo() == null ? "" : u.getSexo())
                    + "','" + (u.getTelefonoCasa() == null ? "" : u.getTelefonoCasa())
                    + "','" + (u.getTelefonoCelular() == null ? "" : u.getTelefonoCelular())
                    + "','" + (u.getDireccion() == null ? "" : u.getDireccion())
                    + "','" + (u.getFechaNacimiento() == null ? "" : u.getFechaNacimiento())
                    + "','" + (u.getNacionalidad() == null ? "v" : u.getNacionalidad())
                    + "')";
            System.out.println(sqlquery);
            Statement s = conexion.createStatement();
            agregados = s.executeUpdate(sqlquery);
            // Ahora agregamos el registro de que no ha modificado sus datos
            Statement v = conexion.createStatement();
            String sqlquery2 = "INSERT into \"PIO\".validoDatos ( "
                    + "cedula)" + "VALUES " + "('"
                    + u.getCedula() + "')";
            System.out.println(sqlquery2);
            validado = v.executeUpdate(sqlquery2);
        } catch (SQLException s) {
            System.out.print(s);
        }
        return agregados > 0 && validado > 0;
    }

    /**
     * Metodo para agregar un registro a la base de datos recibe el objeto
     * Usuario y lo intenta agregar a la base de datos
     *
     * @param Usuario u que representa el usuario a agregar a los registros
     * @return True si puede agregarlo false en otros casos
     */
    public boolean agregarRegistro(Usuario u, int rol) {
        int agregados = 0;
        try {
            String sqlquery = "INSERT INTO \"PIO\".registro("
                    + "cedula, rol, clave,fechaingreso) "
                    + "VALUES ('" + u.getCedula()
                    + "','" + rol
                    + "','" + u.getCedula()
                    + "','"
                    + getCurrentTime()
                    + "')";
            System.out.println(sqlquery);
            Statement s = conexion.createStatement();
            agregados = s.executeUpdate(sqlquery);
        } catch (SQLException s) {
            System.out.print(s);
        }
        return agregados > 0;
    }

    /**
     * Metodo para eliminar un usuario a la base de datos recibe el objeto a
     * eliminar y lo intenta eliminar a la base de datos
     *
     * @param Usuario u que representa el usuario a eliminar
     * @return True si puede eiminarlo false en otros casos
     */
    public boolean eliminarUsuario(Usuario u) {
//    if (!conectar()) {
//      return false;
//    }
        int eliminados = 0;
        try {
            String sqlquery = "DELETE FROM \"PIO\".usuario WHERE "
                    + "cedula = '" + u.getCedula()
                    + "'";
            System.out.println(sqlquery);
            Statement s = conexion.createStatement();
            eliminados = s.executeUpdate(sqlquery);
        } catch (SQLException s) {
            System.out.print(s);
        }
        return eliminados > 0;
    }

//  public Usuario buscarUsuario(int Cedula) {
//    ResultSet rs;
//    try {
//      Statement s = conexion.createStatement();
//      rs = s.executeQuery("SELECT * FROM Usuario WHERE Cedula = "
//              + u.getCedula() + "; ");
//      if (!rs.next()) {
//        return null;
//      }
//      return new Usuario(rs.getInt("Cedula"), rs.getString("Nombres"),
//              rs.getString("Apellidos"), rs.getString("Correo"),
//              rs.getString("Sexo"), rs.getInt("TfCasa"),
//              rs.getInt("TfCelular"));
//    } catch (Exception e) {
//      return null;
//    }
//  }
    /**
     * Metodo para agregar un aspirante a la base de datos recibe el objeto
     * aspirante a agregar y lo intenta agregar a la base de datos
     *
     * @param Aspirante a que representa el aspirante a agregar
     * @return True si puede agregarlo false en otros casos
     */
    public boolean agregarAspirante(Aspirante c) {
        int rs = 0;
        boolean agregoUsuario = agregarUsuario((Usuario) c);
        if (agregoUsuario) {
            boolean agregoRol = agregarRegistro((Usuario) c, 4);
            if (!agregoRol) {
                this.eliminarUsuario(c);
                return false;
            } else {
                try {
                    String sql = "INSERT INTO \"PIO\".aspirante"
                            + "(cedula, "
                            + (c.getPromedio() != null ? "promedio," : "") + "institucionid,"
                            + "datoscompletos) "
                            + "VALUES ("
                            + "'" + c.getCedula() + "'"
                            + ", " + c.getPromedio()
                            + ", " + c.getInstitucionId()
                            + ", " + ((null == c.getDatosCompletos() || !c.getDatosCompletos()) ? 0 : 1)
                            + ")";
                    System.out.println(sql);
                    Statement stmt = conexion.createStatement();
                    rs = stmt.executeUpdate(sql);
                } catch (SQLException s) {
                    System.out.print("error agregando aspirante");
                    if (!this.eliminarUsuario(c)) {
                        System.out.println("BORRAR USUARIO: " + c);
                    }
                    return false;
                }
                return rs > 0;
            }
        }
        return false;
    }

    public boolean eliminarAspirante(Aspirante c) {
        int eliminados = 0;
        try {
            String sqlquery = "DELETE FROM \"PIO\".usuario WHERE "
                    + "cedula = '" + c.getCedula()
                    + "'";
            System.out.println(sqlquery);
            Statement s = conexion.createStatement();
            eliminados = s.executeUpdate(sqlquery);
        } catch (SQLException s) {
        }
        return eliminados > 0;
    }

//  /** Metodo para finalizar  una conexion a la base de datos
//   */
//  protected void finalize() throws Throwable {
//    try {
//      conexion.close();
//    } finally {
//      conexion = null;
//      super.finalize();
//    }
//  }
    /**
     * Metodo para consultar la lista de preseleccionados
     *
     * @return List preseleccionados
     */
    public ArrayList consultarAspirantes() {
        ArrayList aspirantes = new ArrayList();
        try {
            String sqlquery = "SELECT usuario.* , aspirante.*, "
                    + "institucion.nombre AS institucion "
                    + "FROM \"PIO\".aspirante "
                    + "NATURAL JOIN \"PIO\".usuario "
                    + "JOIN \"PIO\".institucion ON aspirante.institucionid = institucion.id "
                    + "ORDER BY institucion, apellidos, nombres, promedio";
            Statement stmt = conexion.createStatement();
            System.out.println(sqlquery + "antes de ejecutarla");
            ResultSet rs = stmt.executeQuery(sqlquery);
            System.out.println(sqlquery + "luego de ejecutarla");
            // Esto me va a permitir veer cuando cambio de institucion
            int id = 0;
            InstitucionAspirante i = new InstitucionAspirante();
            ArrayList<Aspirante> l = new ArrayList<Aspirante>();
            while (rs.next()) {
                if (id == 0) {
                    // La pongo inicialmente
                    id = rs.getInt("institucionId");
                    i.setId(id);
                    i.setNombre(rs.getString("institucion"));
                }
                if (id != rs.getInt("institucionId")) {
                    // Institucion nueva
                    i.setAspirantes(l);
                    aspirantes.add(i);
                    l = new ArrayList<Aspirante>();
                    i = new InstitucionAspirante();
                    id = rs.getInt("institucionId");
                    i.setId(id);
                    i.setNombre(rs.getString("institucion"));
                }
                Aspirante a = new Aspirante();
                this.setAtts(a, rs);
                a.setInstitucionId(rs.getInt("institucionId"));
                a.setPromedio(rs.getDouble("promedio"));
                a.setDatosCompletos((rs.getInt("datoscompletos") == 0 ? false : true));
                l.add(a);
            }
            if (id != 0) {
                // La ultima vez me falta agregar los que estaban en l
                i.setAspirantes(l);
                aspirantes.add(i);
            }
        } catch (SQLException s) {
            System.out.print(s);
        }
        System.out.println("Retornando del metodo consultarAspirantes");
        return aspirantes;
    }

    /**
     *
     * @param aspirante
     * @return
     */
    public ArrayList<InstitucionAspirante> consultarAspirantes(Aspirante aspirante) {
        ArrayList aspirantes = new ArrayList<InstitucionAspirante>();
        String sqlquery = "SELECT usuario.* , aspirante.*, "
                + "institucion.nombre AS institucion "
                + "FROM \"PIO\".usuario "
                + "NATURAL JOIN (\"PIO\".aspirante "
                + "JOIN \"PIO\".institucion ON aspirante.institucionid = institucion.id) ";
        try {
            boolean hayparam = false;
            String condicion = "" + this.construirCondicionUsuario(aspirante, true);
            System.out.println("Condicion construida con atributos de usuario: " + condicion);
            if (!condicion.isEmpty()) {
                hayparam = true;
            }
            String tem = "";

            if (null != aspirante.getInstitucionId()) {
                tem = "aspirante.institucionid = " + aspirante.getInstitucionId();
                if (hayparam) {
                    condicion += " AND " + tem;
                } else {
                    condicion = " WHERE " + tem;
                    hayparam = true;
                }
            }
            if (aspirante.getPromedio() != null && aspirante.getPromedio() != 0.0) {
                if (hayparam) {
                    condicion += " AND aspirante.promedio = " + aspirante.getPromedio();
                } else {
                    condicion += " WHERE aspirante.promedio = " + aspirante.getPromedio();
                    hayparam = true;
                }
            }
            if (null != aspirante.getDatosCompletos()) {
                if (hayparam) {
                    condicion += " AND aspirante.datoscompletos = " + (aspirante.getDatosCompletos() ? 1 : 0);
                } else {
                    condicion += " WHERE aspirante.datoscompletos = " + (aspirante.getDatosCompletos() ? 1 : 0);
                    hayparam = true;
                }
            }
            if (hayparam) {
                sqlquery += " " + condicion + " ORDER BY institucion, apellidos, nombres, promedio";
            } else {
                System.out.println("Se esta regresando toda la lista");
            }
            System.out.println(sqlquery + " // Antes de ejecutarla");
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            System.out.println(sqlquery + " // Luego de ejecutarla");
            // Esto me va a permitir veer cuando cambio de institucion
            int id = 0;
            InstitucionAspirante i = new InstitucionAspirante();
            ArrayList<Aspirante> l = new ArrayList<Aspirante>();
            while (rs.next()) {
                if (id == 0) {
                    // La pongo inicialmente
                    id = rs.getInt("institucionId");
                    i.setId(id);
                    i.setNombre(rs.getString("institucion"));
                }
                if (id != rs.getInt("institucionId")) {
                    // Institucion nueva
                    i.setAspirantes(l);
                    aspirantes.add(i);
                    l = new ArrayList<Aspirante>();
                    i = new InstitucionAspirante();
                    id = rs.getInt("institucionId");
                    i.setId(id);
                    i.setNombre(rs.getString("institucion"));
                }
                Aspirante a = new Aspirante();
                this.setAtts(a, rs);
                a.setInstitucionId(rs.getInt("institucionId"));
                a.setPromedio(rs.getDouble("promedio"));
                a.setDatosCompletos((rs.getInt("datoscompletos") == 0 ? false : true));
                l.add(a);
            }
            if (id != 0) {
                // La ultima vez me falta agregar los que estaban en l
                i.setAspirantes(l);
                aspirantes.add(i);
            }
        } catch (SQLException s) {
            System.out.println(s);
        }
        return aspirantes;
    }

    public ArrayList<Aspirante> consultarAspirantesTestCompletado() {
        ArrayList aspirantes = new ArrayList();
        try {
            String sqlquery = "SELECT * "
                    + " FROM \"PIO\".aspirante "
                    + " NATURAL JOIN \"PIO\".usuario "
                    + " WHERE datoscompletos = 1 "
                    + " ORDER BY institucionid";
            System.out.println(sqlquery);
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                Aspirante aspi = new Aspirante();
                aspi.setCedula(rs.getString("cedula"));
                aspi.setNombres(rs.getString("nombres"));
                aspi.setApellidos(rs.getString("apellidos"));
                aspi.setPromedio(rs.getDouble("promedio"));
                aspi.setInstitucionId(new Integer(rs.getInt("institucionid")));
                aspirantes.add(aspi);
                System.out.println(aspi.toString());
            }
        } catch (SQLException s) {
        }
        return aspirantes;
    }

    public ArrayList<Aspirante> consultarTodosAspirantes() {
        ArrayList aspirantes = new ArrayList();
        try {
            String sqlquery = "SELECT * "
                    + " FROM \"PIO\".aspirante "
                    + " NATURAL JOIN \"PIO\".usuario "
                    + " ORDER BY cedula";
            System.out.println(sqlquery);
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                Aspirante aspi = new Aspirante();
                aspi.setCedula(rs.getString("cedula"));
                aspi.setNombres(rs.getString("nombres"));
                aspi.setApellidos(rs.getString("apellidos"));
                aspi.setPromedio(rs.getDouble("promedio"));
                aspi.setInstitucionId(new Integer(rs.getInt("institucionid")));
                aspirantes.add(aspi);
                System.out.println(aspi.toString());
            }
        } catch (SQLException s) {
        }
        return aspirantes;
    }

    public int consultarNumPreselectos() {
        int num = 0;
        try {

            String sqlquery = "SELECT COUNT(*) "
                    + " FROM \"PIO\".aspirante "
                    + " NATURAL JOIN \"PIO\".usuario "
                    + " WHERE promedio>12.5";
            System.out.println(sqlquery);
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                num = rs.getInt(1);
            }
        } catch (SQLException s) {
        }
        return num;
    }

    public boolean modificarUsuario(Usuario u) {

        try {
            String sqlquery = "UPDATE \"PIO\".usuario ";
            boolean hayparam = false;
            if (u.getNombres() != null && !u.getNombres().isEmpty()) {
                sqlquery = sqlquery + "SET nombres = '" + u.getNombres() + "'";
                hayparam = true;
            }

            if (u.getApellidos() != null && !u.getApellidos().isEmpty()) {
                if (hayparam) {
                    sqlquery = sqlquery + ", apellidos = '" + u.getApellidos() + "'";
                } else {
                    sqlquery = sqlquery + "SET apellidos = '" + u.getApellidos() + "'";
                }
                hayparam = true;
            }
            if (u.getCorreo() != null && !u.getCorreo().isEmpty()) {
                if (hayparam) {
                    sqlquery = sqlquery + ", correo = '" + u.getCorreo() + "'";
                } else {
                    sqlquery = sqlquery + "SET correo = '" + u.getCorreo() + "'";
                }
                hayparam = true;
            }
            if (u.getSexo() != null && !u.getSexo().isEmpty()) {
                if (hayparam) {
                    sqlquery = sqlquery + ", sexo = '" + u.getSexo() + "'";
                } else {
                    sqlquery = sqlquery + "SET sexo = '" + u.getSexo() + "'";
                }
                hayparam = true;
            }

            if (u.getTelefonoCasa() != null && !u.getTelefonoCasa().isEmpty()) {
                if (hayparam) {
                    sqlquery = sqlquery + ", telefonoCasa = '" + u.getTelefonoCasa() + "'";
                } else {
                    sqlquery = sqlquery + "SET telefonoCasa = '" + u.getTelefonoCasa() + "'";
                }
                hayparam = true;
            }

            if (u.getTelefonoCelular() != null && !u.getTelefonoCelular().isEmpty()) {
                if (hayparam) {
                    sqlquery = sqlquery + ", telefonoCelular = '" + u.getTelefonoCelular() + "'";
                } else {
                    sqlquery = sqlquery + "SET telefonoCelular = '" + u.getTelefonoCelular() + "'";
                }
                hayparam = true;
            }

            if (u.getDireccion() != null && !u.getDireccion().isEmpty()) {
                if (hayparam) {
                    sqlquery = sqlquery + ", direccion = '" + u.getDireccion() + "'";
                } else {
                    sqlquery = sqlquery + "SET direccion = '" + u.getDireccion() + "'";
                }
                hayparam = true;
            }
            if (u.getFechaNacimiento() != null && !u.getFechaNacimiento().isEmpty()) {
                if (hayparam) {
                    sqlquery = sqlquery + ",fechaNacimiento = '" + u.getFechaNacimiento() + "'";
                } else {
                    sqlquery = sqlquery + "SET fechaNacimiento = '" + u.getFechaNacimiento() + "'";
                }
                hayparam = true;
            }
            if (u.getNacionalidad() != null && !u.getNacionalidad().isEmpty()) {
                if (hayparam) {
                    sqlquery = sqlquery + ", nacionalidad = '" + u.getNacionalidad() + "'";
                } else {
                    sqlquery = sqlquery + "SET nacionalidad = '" + u.getNacionalidad() + "'";
                }
                hayparam = true;
            }
            sqlquery = sqlquery + " WHERE cedula = '" + u.getCedula() + "'";
            Statement stmt = conexion.createStatement();
            System.out.println(sqlquery);
            if (stmt.executeUpdate(sqlquery) > 0) {
                System.out.println("se updatearon los datos");
                String sqlquery2 = " UPDATE \"PIO\".validodatos SET valido = 't' "
                        + " WHERE cedula = " + "\'" + u.getCedula() + "\'";
                Statement st = conexion.createStatement();
                int modificoDatos = st.executeUpdate(sqlquery2);
                if (modificoDatos <= 0) {
                    System.out.print(" Se modifico el usuario pero no se pudo colocar en true"
                            + "el validar los datos ");
                }
                return modificoDatos > 0;
            } else {
                System.out.println("problemas con el update ");
                return false;
            }
        } catch (SQLException s) {
            System.out.println(s);
        }
        return true;
    }

    public boolean modificarAspirante(Aspirante aspirante) {
        this.modificarUsuario((Usuario) aspirante);
        try {
            String sqlquery = "UPDATE \"PIO\".\"aspirante\" ";
            boolean hayparam = false;
            if (aspirante.getInstitucionId() != null) {
                if (aspirante.getInstitucionId() != 0) {
                    if (hayparam) {
                        sqlquery = sqlquery + ", institucionid = '" + aspirante.getInstitucionId() + "'";
                    } else {
                        sqlquery = sqlquery + "SET institucionid = '" + aspirante.getInstitucionId() + "'";
                    }
                    hayparam = true;
                }
            }

            if (aspirante.getPromedio() != null && aspirante.getPromedio() != 0.0) {
                if (hayparam) {
                    sqlquery = sqlquery + ", promedio = '" + aspirante.getPromedio() + "'";
                } else {
                    sqlquery = sqlquery + "SET promedio = '" + aspirante.getPromedio() + "'";
                }
                hayparam = true;
            }

            if (null != aspirante.getDatosCompletos()) {
                if (hayparam) {
                    sqlquery = sqlquery + ", datoscompletos = " + (aspirante.getDatosCompletos() ? 1 : 0);
                } else {
                    sqlquery = sqlquery + "SET datoscompletos = " + (aspirante.getDatosCompletos() ? 1 : 0);
                }
            }
            sqlquery = sqlquery + " WHERE cedula = '" + aspirante.getCedula() + "'";
            System.out.println(sqlquery);
            Statement stmt = conexion.createStatement();
            return stmt.executeUpdate(sqlquery) > 0;
        } catch (SQLException s) {
        }
        return true;

    }

    public int numeroAspirantes() {
//    if (!conectar()) {
//      return 0;
//    }
        try {
            String sqlquery = "SELECT COUNT(*) "
                    + "FROM \"PIO\".\"aspirante\" ";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            if (rs.next()) {
                return rs.getInt(1);
            }
        } catch (SQLException s) {
        }
        return 0;
    }

    public int generarReportePreseleccion() {
        int lista = 0;
//    if (!conectar()) {
//      return -1;
//    }
        try {
            String sqlquery = "SELECT COUNT(*) AS rowcount "
                    + "FROM \"PIO\".\"aspirante\" "
                    + "WHERE promedio >= '12.5'";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            rs.next();
            lista = (Integer) rs.getInt("rowcount");
        } catch (SQLException s) {
        }
        return lista;
    }

    public List consultarPreselectos() {
        ArrayList aspirantes = new ArrayList();
//    if (!conectar()) {
//      return aspirantes;
//    }
        try {
            String sqlquery = "SELECT * "
                    + " FROM \"PIO\".aspirante "
                    + " NATURAL JOIN \"PIO\".usuario "
                    + " WHERE promedio >= 12.5 "
                    + " ORDER BY cedula";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                aspirantes.add(new Integer(rs.getInt("cedula")));
                aspirantes.add(rs.getString("nombres"));
                aspirantes.add(rs.getString("apellidos"));
            }
        } catch (SQLException s) {
        }
        return aspirantes;
    }

    public List consultarPreselectosPorInstitucion() {
        ArrayList inst = new ArrayList();
//    if (!conectar()) {
//      return inst;
//    }
        try {
            String sqlquery = "SELECT institucion.nombre , COUNT(*) "
                    + " FROM \"PIO\".aspirante "
                    + " JOIN \"PIO\".institucion ON aspirante.institucionid = institucion.id "
                    + " WHERE promedio >= 12.5 "
                    + " GROUP BY institucion.id, institucion.nombre";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                ArrayList temp = new ArrayList();
                temp.add(rs.getString(1));
                temp.add(new Integer(rs.getInt(2)));
                inst.add(temp);
            }
        } catch (SQLException s) {
        }
        return inst;
    }

    public List consultarNoPreselectosPorInstitucion() {
        ArrayList inst = new ArrayList();
//    if (!conectar()) {
//      return inst;
//    }
        try {
            String sqlquery = "SELECT institucion.nombre , COUNT(*) "
                    + " FROM \"PIO\".aspirante "
                    + " JOIN \"PIO\".institucion ON aspirante.institucionid = institucion.id "
                    + " WHERE promedio < 12.5 "
                    + " GROUP BY institucion.id, institucion.nombre";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                ArrayList temp = new ArrayList();
                temp.add(rs.getString(1));
                temp.add(new Integer(rs.getInt(2)));
                inst.add(temp);
            }
        } catch (SQLException s) {
        }
        return inst;
    }

    public boolean modificarfechaPrueba(Periodo period) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    public String fechaPrueba(Periodo period) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    public List consultarProfesores() {
        ArrayList profesores = new ArrayList();
//    if (!conectar()) {
//      return profesores;
//    }
        try {
            String sqlquery = "SELECT usuario.* , profesor.* "
                    + "FROM \"PIO\".\"profesor\" "
                    + "NATURAL JOIN \"PIO\".\"usuario\"";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                Profesor temp = new Profesor();
                temp.setCedula(rs.getString("cedula"));
                temp.setNombres(rs.getString("nombres"));
                temp.setApellidos(rs.getString("apellidos"));
                temp.setCorreo(rs.getString("correo"));
                temp.setNivel(rs.getInt("nivel"));
                profesores.add(temp);
            }
        } catch (SQLException s) {
        }
        return profesores;
    }

    public boolean agregarProfesor(Profesor profesor) {
        int agregado = 0;
        String sqlquery = "No me han inicializado :D";
        boolean nivel = false;
        try {
            if (!agregarUsuario(profesor)) {
                return false;
            }
            if (!agregarRegistro(profesor, 1)) {
                return false;
            }
            sqlquery = "INSERT INTO \"PIO\".\"profesor\" ("
                    + "\"cedula\"";
            if (profesor.getNivel() != 0) {
                nivel = true;
                sqlquery += ", \"nivel\" ";
            }
            sqlquery += ") VALUES ('" + profesor.getCedula();
            if (nivel) {
                sqlquery += "','" + profesor.getNivel();
            }
            sqlquery += "')";
            Statement s = conexion.createStatement();
            agregado = s.executeUpdate(sqlquery);
            if (agregado == 0) {
                eliminarUsuario(profesor);
            }

        } catch (SQLException s) {
            eliminarUsuario(profesor);
        }
        return agregado > 0;

    }

    public List consultarProfesor(Profesor profesor) {
        ArrayList profesores = new ArrayList();

        String sqlquery = "SELECT usuario.* , nivel "
                + "FROM \"PIO\".\"profesor\" "
                + "NATURAL JOIN \"PIO\".\"usuario\" ";
        try {
            boolean hayparam = false;
            String condicion = "";
            String tem = "";
            if (Integer.valueOf(profesor.getCedula()) != 0) {
                condicion = condicion + "profesor.cedula = '" + profesor.getCedula() + "'";
                hayparam = true;
            }
            if (profesor.getNombres() != null && !profesor.getNombres().equals("null") && !profesor.getNombres().isEmpty()) {
                tem = "profesor.nombres = '" + profesor.getNombres() + "'";
                if (hayparam) {
                    condicion = condicion + "," + tem;
                } else {
                    condicion = tem;
                }
                hayparam = true;
            }
            if (profesor.getApellidos() != null && !profesor.getApellidos().equals("null") && !profesor.getApellidos().isEmpty()) {
                tem = "profesor.apellidos = '" + profesor.getApellidos() + "'";
                if (hayparam) {
                    condicion = condicion + "," + tem;
                } else {
                    condicion = tem;
                }
                hayparam = true;
            }
            if (profesor.getCorreo() != null && !profesor.getCorreo().equals("null") && !profesor.getCorreo().isEmpty()) {
                tem = "profesor.correo = '" + profesor.getCorreo() + "'";
                if (hayparam) {
                    condicion = condicion + "," + tem;
                } else {
                    condicion = tem;
                }
                hayparam = true;
            }
            if (profesor.getNivel() > 0) {
                tem = "profesor.nivel = '" + profesor.getNivel() + "'";
                if (hayparam) {
                    condicion = condicion + "," + tem;
                } else {
                    condicion = tem;
                }
                hayparam = true;
            }
            if (hayparam) {
                sqlquery += "WHERE " + condicion + " ORDER BY cedula, apellidos, nombres";
            } else {
                return profesores;
            }
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                Profesor temp = new Profesor();
                this.setAtts(temp, rs);
                temp.setNivel(rs.getInt("nivel"));
                profesores.add(temp);
            }
        } catch (SQLException s) {
//      profesor.setMensaje(s.toString());
        }
        return profesores;
    }

    public boolean eliminarProfesor(Profesor profesor) {
        return eliminarUsuario(profesor);
    }

    public boolean modificarProfesor(Profesor profesor) {
        modificarUsuario(profesor);
        try {
            if (profesor.getNivel() != 0) {
                String sqlquery = "UPDATE \"PIO\".\"profesor\" "
                        + "SET nivel = '" + profesor.getNivel() + "' "
                        + "WHERE cedula = '" + profesor.getCedula() + "'";
                Statement stmt = conexion.createStatement();
                return stmt.executeUpdate(sqlquery) > 0;
            }
        } catch (SQLException s) {
        }
        return true;
    }

    public List consultarContactos(String state) {
        ArrayList lista = new ArrayList();
//    if (!conectar()) {
//      return lista;
//    }
        try {
            String sqlquery = "SELECT * "
                    + "FROM \"PIO\".contacto "
                    + "WHERE leido='" + state + "'"
                    + "ORDER BY fechaEnvio";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                Contacto temp = new Contacto();
                temp.setCorreo(rs.getString("correo"));
                temp.setFuente(rs.getString("fuente"));
                temp.setInformacion(rs.getString("informacion"));
                temp.setFechaEnvio(rs.getString("fechaEnvio"));
                temp.setId(rs.getInt("id"));
                lista.add(temp);
            }
        } catch (SQLException s) {
        }
        return lista;
    }
    // guarda en la base de dato el Contacto y retorna true si lo logro de lo contrario false

    public boolean agregarContacto(Contacto u) {
        int rs = 0;
        if (!conectar()) {
            return false;
        }
        try {
            String sql = "INSERT INTO \"PIO\".contacto(informacion, "
                    + "fuente, correo,fechaenvio) VALUES ('"
                    + u.getInformacion() + "','"
                    + u.getFuente() + "','"
                    + u.getCorreo() + "','"
                    + this.obtenerFechaActualDB() + "')";
            System.out.println(sql);
            Statement stmt = conexion.createStatement();
            rs = stmt.executeUpdate(sql);
        } catch (SQLException s) {
            System.out.println(s.getMessage());
        }
        return rs > 0;
    }

    public boolean consultarMiInformacion(Participante p) {
//    if (!conectar()) {
//      return false;
//    }
        try {
            String sqlquery = "SELECT * "
                    + "FROM \"PIO\".usuario "
                    + "WHERE cedula = '"
                    + p.getCedula() + "'";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            if (rs.next()) {
                if (!rs.getString("nombres").equals("null")) {
                    p.setNombres(rs.getString("nombres"));
                } else {
                    p.setNombres("");
                }
                if (!rs.getString("apellidos").equals("null")) {
                    p.setApellidos(rs.getString("apellidos"));
                } else {
                    p.setApellidos("");
                }
                if (!rs.getString("correo").equals("null")) {
                    p.setCorreo(rs.getString("correo"));
                } else {
                    p.setCorreo("");
                }
            } else {
                return false;
            }
            sqlquery = "SELECT * "
                    + "FROM \"PIO\".aspirante "
                    + "WHERE cedula = '"
                    + p.getCedula() + "'";
            rs = stmt.executeQuery(sqlquery);
            if (rs.next()) {
                p.setInstitucionId(rs.getInt("institucionId"));
                p.setPromedio(rs.getDouble("promedio"));
            } else {
                return false;
            }
            sqlquery = "SELECT * "
                    + "FROM \"PIO\".preinscrito "
                    + "WHERE cedula = '"
                    + p.getCedula() + "'";
            rs = stmt.executeQuery(sqlquery);
            if (rs.next()) {
//                p.setNumeroPreinscripcion(rs.getInt("numeroPreinscripcion"));
//                p.setOpcion1(rs.getInt("opcion1"));
//                p.setOpcion2(rs.getInt("opcion2"));
//                p.setOpcion3(rs.getInt("opcion3"));
            } else {
                return true;
            }
            sqlquery = "SELECT * "
                    + "FROM \"PIO\".participante "
                    + "WHERE cedula = '"
                    + p.getCedula() + "'";
            rs = stmt.executeQuery(sqlquery);
            if (rs.next()) {
            }
            return true;
        } catch (SQLException s) {
//      p.setMensaje(s.toString());
        }
        return false;
    }

    /**
     * Metodo para agregar una institucion a la base de datos recibe el objeto
     * institucion a agregar y lo intenta agregar a la base de datoa
     *
     * @param Institucion i que representa el usuario a agregar
     * @return True si puede agregarla false en otros casos
     */
    public boolean agregarInstitucion(Institucion i) {
        int agregados = 0;
        try {
            String sqlquery = "INSERT INTO \"PIO\".institucion("
                    + "nombre, idparada) VALUES ("
                    + "'" + i.getNombre() + "'"
                    + ", " + i.getIdParada()
                    + ")";
            Statement s = conexion.createStatement();
            agregados = s.executeUpdate(sqlquery);
            System.out.print(sqlquery);
            sqlquery = "SELECT * FROM \"PIO\".institucion "
                    + "WHERE nombre = '" + i.getNombre() + "'";
            ResultSet rs = s.executeQuery(sqlquery);
            if (rs.next()) {
                i.setId(rs.getInt("id"));
                agregados = i.getId();
            }
        } catch (SQLException s) {
            System.out.print(s);
        }
        return agregados > 0;
    }

    public ArrayList consultarInstituciones() {
        ArrayList lista = new ArrayList();
//    if (!conectar()) {
//      return lista;
//    }
        try {
            String sqlquery = "SELECT * "
                    + "FROM \"PIO\".institucion "
                    + "ORDER BY nombre";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                Institucion temp = new Institucion();
                temp.setId(rs.getInt("id"));
                temp.setNombre(rs.getString("nombre"));
                temp.setIdParada(rs.getInt("idparada"));
                lista.add(temp);
            }
        } catch (SQLException s) {
        }
        return lista;
    }

    public boolean eliminarInstitucion(Institucion i) {
//    if (!conectar()) {
//      return false;
//    }
        int eliminados = 0;
        try {
            String sqlquery = "DELETE FROM \"PIO\".institucion WHERE "
                    + "id = " + i.getId() + " AND NOT EXISTS(SELECT * FROM"
                    + " \"PIO\".coordinador WHERE institucionId = " + i.getId() + ")";
            System.out.println(sqlquery);
            Statement s = conexion.createStatement();
            eliminados = s.executeUpdate(sqlquery);
        } catch (SQLException s) {
            System.out.println(s.getMessage());
            return false;
        }
        return eliminados > 0;
    }

    public ArrayList<Institucion> consultarInstitucion(Institucion i) {
        ArrayList instituciones = new ArrayList();
        String sqlquery = "SELECT * FROM \"PIO\".institucion ";
        try {
            boolean hayparam = false;
            String condicion = "";
            String tem = "";
            if (i.getId() > 0) {
                condicion = condicion + "id = '" + i.getId() + "'";
                hayparam = true;
            }
            if (i.getNombre() != null && !i.getNombre().isEmpty()) {
                tem = " " + crearLike("nombre", i.getNombre());
                if (hayparam) {
                    condicion = condicion + " AND " + tem;
                } else {
                    condicion = tem;
                }
                hayparam = true;
            }
            if (null != i.getIdParada()) {
                if (!hayparam) {
                    condicion += " idparada = " + i.getIdParada();
                    hayparam = true;
                } else {
                    condicion += " AND idparada = " + i.getIdParada();
                }
            }
            if (hayparam) {
                sqlquery += " WHERE " + condicion + " ORDER BY nombre";
            }

            System.out.println(sqlquery);
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                Institucion temp = new Institucion();
                temp.setId(rs.getInt("id"));
                temp.setNombre(rs.getString("nombre"));
                temp.setIdParada(rs.getInt("idparada"));
                instituciones.add(temp);
            }
        } catch (SQLException s) {
        }
        return instituciones;
    }

    public boolean modificarInstitucion(Institucion i) {
        String sqlquery;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return false;
            }

            sqlquery = "UPDATE \"PIO\".institucion";

            if ((null != i.getNombre()) && !i.getNombre().isEmpty()) {
                if (isFirst) {
                    sqlquery += " SET nombre = '" + i.getNombre() + "'";
                    isFirst = false;
                } else {
                    sqlquery += ", nombre = '" + i.getNombre() + "'";
                }
            }

            if (null != i.getIdParada()) {
                if (isFirst) {
                    sqlquery += " SET idparada = " + i.getIdParada();
                    isFirst = false;
                } else {
                    sqlquery += ", idparada = " + i.getIdParada();
                }
            }
            sqlquery += " WHERE id = '" + i.getId() + "'";
            System.out.println(sqlquery);
            Statement stmt = conexion.createStatement();
            return stmt.executeUpdate(sqlquery) > 0;
        } catch (SQLException s) {
        }
        return true;
    }

    public int numeroInstituciones() {
        if (!conectar()) {
            return 0;
        }
        try {
            String sqlquery = "SELECT COUNT(*) "
                    + "FROM \"PIO\".institucion ";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            if (rs.next()) {
                return rs.getInt(1);
            }
        } catch (SQLException s) {
        }
        return 0;
    }

    /**
     * Agrega una parada alterna para una institucion en un turno particular
     *
     * @param i Objeto con la información de la institución a la que se le a
     * agregará la parada alterna
     * @param t Objeto que contiene la información del turno en el que se
     * agregará la parada alterna
     * @param p Información de la parada alterna a agregar
     * @return true si la operación tuvo éxito, false en caso contrario
     */
    public boolean agregarParadaAlterna(Institucion i, Turno t, Parada p) {
        String query;
        Statement st;
        int agregados;
        ResultSet test;
        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            query = "SELECT * FROM \"PIO\".parada_alterna WHERE idinstitucion = "
                    + i.getId() + " AND idturno = " + t.getId();

            System.out.println("Verificando si ya existe la entrada: " + query);
            st = conexion.createStatement();
            test = st.executeQuery(query);

            if (test.next()) {
                query = "UPDATE \"PIO\".parada_alterna SET idparada = " + p.getId()
                        + " WHERE idinstitucion = " + i.getId()
                        + " AND idturno = " + t.getId();
            } else {
                query = "INSERT INTo \"PIO\".parada_alterna(idinstitucion, idturno,"
                        + "idparada) VALUES("
                        + i.getId()
                        + ", " + t.getId()
                        + ", " + p.getId()
                        + ")";
            }

            System.out.println(query);
            agregados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return agregados > 0;
    }

    /**
     * Método que asigna a todas las instituciones cuyos preinscritos están
     * asignados a un turno particular una parada alterna común. Si la
     * institución ya posee una parada alterna, la misma es sustituida
     *
     * @param t Objeto con la infromación del turno que se desea consultar
     * @param p Objeto con la información de la parada alterna a agregar
     * @return
     */
    public boolean agregarParadaAlterna(Turno t, Parada p) {
        String query;
        Statement st;
        ResultSet rs;
        ArrayList<Integer> instId = new ArrayList<Integer>();

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            //Primero se modifican las instituciones que ya tienen una parada 
            //alterna asignada para este turno
            query = "UPDATE \"PIO\".parada_alterna \n"
                    + "SET idparada = " + p.getId() + "\n"
                    + "WHERE idturno = " + t.getId();

            System.out.println(query);
            st = conexion.createStatement();
            st.executeUpdate(query);

            //Ahora se buscan todas las instituciones que poseen preinscritos en el
            //turno deseado y que aún no poseen una parada alterna en ese turno
            query = "SELECT * FROM \"PIO\".institucion i\n"
                    + " WHERE EXISTS (\n"
                    + "   SELECT * FROM \"PIO\".preinscrito NATURAL JOIN \"PIO\".aspirante\n"
                    + "     WHERE institucionid = i.id\n"
                    + "           AND\n"
                    + "           turnoprueba = " + t.getId() + ")\n"
                    + " AND NOT EXISTS (\n"
                    + "    SELECt * FROM \"PIO\".parada_alterna\n"
                    + "      WHERE idinstitucion = i.id\n"
                    + "            AND\n"
                    + "            idturno = " + t.getId() + ")";

            System.out.println(query);
            rs = st.executeQuery(query);
            while (rs.next()) {
                instId.add(rs.getInt("id"));
            }

            for (Integer i : instId) {
                query = "INSERT INTO \"PIO\".parada_alterna(idinstitucion,idparada,idturno)\n"
                        + " VALUES("
                        + i
                        + ", " + p.getId()
                        + ", " + t.getId()
                        + ")";

                System.out.println(query);
                st.executeUpdate(query);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return true;
    }

    /**
     * Método que dado una aprada y un turno, agrega a todas las instituciones
     * que poseen como parada principal la indicada, y poseen al menos un
     * preinscrito en el turno indicado, la parada alterna que se pasa de
     * parámetro en el turno indicado. Si alguna institución ya poseía una
     * parada alterna para el turno indicado, la misma será sobreescrita
     *
     * @param pCons Objeto con la información de la parada original a consultar
     * @param t Objeto con la información del turno a consultar
     * @param palt Objeto con la información de la parada que se agregará como
     * alterna
     * @return true si la operación tuvo éxito, false en caso contrario
     */
    public boolean agregarParadaAlterna(Parada pCons, Turno t, Parada pAlt) {
        Statement st;
        ResultSet rs;
        String query;
        ArrayList<Integer> ins = new ArrayList<Integer>();

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            //Se obtienen los id de las instituciones que apliquen a ser agregadas
            query = "SELECT * FROM \"PIO\".institucion i\n"
                    + " WHERE idparada = " + pCons.getId() + "\n"
                    + " AND\n"
                    + " EXISTS (SELECT * FROM \"PIO\".aspirante NATURAL JOIN \"PIO\".preinscrito\n"
                    + "           WHERE institucionid = i.id\n"
                    + "                 AND\n"
                    + "                  turnoprueba = " + t.getId() + ")";

            System.out.println(query);
            st = conexion.createStatement();
            rs = st.executeQuery(query);
            while (rs.next()) {
                ins.add(rs.getInt(1));
            }

            rs.close();
            for (Integer id : ins) {
                query = "SELECT * FROM \"PIO\".parada_alterna \n"
                        + "  WHERE idinstitucion = " + id + "\n"
                        + "         AND\n"
                        + "        idturno = " + t.getId();

                System.out.println(query);
                rs = st.executeQuery(query);
                if (rs.next()) {
                    query = "UPDATE \"PIO\".parada_alterna\n"
                            + " SET idparada = " + pAlt.getId() + "\n"
                            + " WHERE idinstitucion = " + id + "\n"
                            + "       AND\n"
                            + "       idturno = " + t.getId();
                } else {
                    query = "INSERT INTO \"PIO\".parada_alterna(idinstitucion, idparada, idturno)\n"
                            + " VALUES("
                            + "  " + id
                            + ", " + pAlt.getId()
                            + ", " + t.getId()
                            + ")";
                }

                System.out.println(query);
                rs.close();
                st.executeUpdate(query);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return true;
    }

    /**
     * Devuelve, para una institución particular, la parada alterna que le ha
     * sido asignada para un turno particular
     *
     * @param i Objeto que contiene el id de la institución que se desea
     * consultar
     * @param t Objeto que contiene el id del turno que s edesea consultar
     * @return Objeto que contiene la información de la parada alterna para la
     * institución 'i' en el turno 't'
     */
    public Parada obtenerParadaAlterna(Institucion i, Turno t) {
        String query;
        Parada res = null;
        Statement st;
        ResultSet rs;

        if (null == t.getId()) {
            System.out.println("No se ha especificado el id del turno a consultar");
            return null;
        }

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return null;
            }

            query = "SELECT * FROM \"PIO\".parada_alterna pa JOIN \"PIO\".parada p"
                    + " ON pa.idparada = p.id WHERE idinstitucion = " + i.getId()
                    + " AND idturno = " + t.getId();

            System.out.println(query);
            st = conexion.createStatement();
            rs = st.executeQuery(query);

            if (rs.next()) {
                res = new Parada();
                res.setId(rs.getInt("id"));
                res.setNombre(rs.getString("nombre"));
                res.setDescripcion(rs.getString("descripcion"));
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return null;
        }
        return res;
    }

    /**
     * Asigna a todos los preinscritos de la institución i la sede s
     *
     * @param i Objeto con la información de la institución a actualizar
     * @param s Sede que se le asignará a los alumnos
     * @return true si la operación tuvo éxito, false en caso contrario
     */
    public boolean actualizarSede(Institucion i, String s) {
        String query;
        Statement st;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion está cerrada");
                return false;
            }

            query = "UPDATE \"PIO\".preinscrito p SET"
                    + " sede = '" + s + "'"
                    + " WHERE EXISTS("
                    + "   SELECT * FROM \"PIO\".aspirante a WHERE"
                    + "     a.cedula = p.cedula AND institucionid = " + i.getId()
                    + " )";

            System.out.println(query);
            st = conexion.createStatement();
            st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return true;
    }

    public boolean eliminarContacto(Contacto c) {
//    if (!conectar()) {
//      return false;
//    }
        int eliminados = 0;
        try {
            String sqlquery = "DELETE FROM \"PIO\".contacto WHERE "
                    + "id = '" + c.getId() + "'";
            Statement s = conexion.createStatement();
            eliminados = s.executeUpdate(sqlquery);
        } catch (SQLException s) {
        }
        return eliminados > 0;
    }

    public String getCorreoContacto(String id) {
        String resultado = "";
//    if (!conectar()) {
//      return resultado;
//    }
        try {
            String sqlquery = "SELECT correo "
                    + "FROM \"PIO\".contacto WHERE id = '" + id + "'";
            Statement s = conexion.createStatement();
            ResultSet rs = s.executeQuery(sqlquery);
            rs.next();
            resultado = rs.getString("correo");
        } catch (SQLException s) {
        }
        return resultado;
    }

    public boolean changeState(String id) {
//    if (!conectar()) {
//      return false;
//    }
        try {
            String sqlquery = "UPDATE \"PIO\".\"contacto\" "
                    + "SET leido = 'true'"
                    + "WHERE id = '" + id + "'";
            Statement stmt = conexion.createStatement();
            return stmt.executeUpdate(sqlquery) > 0;
        } catch (SQLException s) {
        }
        return true;
    }

    public boolean agregarInstitucionDatosBasicos(InstitucionDatosBasicos datos) {
        int rs = 0;
        try {
            String sql = "INSERT into \"PIO\".InstitucionDatosBasicos ";
            String label = "(institucionId";
            String values = "VALUES ('" + datos.getInstitucionId() + "'";
            if (!datos.getTelefono().equals("")) {
                label += ",telefono";
                values += ",'" + datos.getTelefono() + "'";
            }
            if (!datos.getFax().equals("")) {
                label += ",fax";
                values += ",'" + datos.getFax() + "'";
            }
            if (!datos.getCorreo().isEmpty()) {
                label += ",correo";
                values += ",'" + datos.getCorreo() + "'";
            }
            if (!datos.getDireccion().isEmpty()) {
                label += ",direccion";
                values += ",'" + datos.getDireccion() + "'";
            }
            if (!datos.getDistrito().isEmpty()) {
                label += ",distrito";
                values += ",'" + datos.getDistrito() + "'";
            }
            if (datos.getTipo() != null) {
                label += ",tipo";
                values += ",'" + datos.getTipo() + "'";
            }
            if (!datos.getCoordinadorNombre().isEmpty()) {
                label += ",coordinadorNombre";
                values += ",'" + datos.getCoordinadorNombre() + "'";
            }
            if (!datos.getCoordinadorCorreo().isEmpty()) {
                label += ",coordinadorCorreo";
                values += ",'" + datos.getCoordinadorCorreo() + "'";
            }
            if (!datos.getCoordinadorTelefonoCasa().equals("")) {
                label += ",coordinadorTelefonoCasa";
                values += ",'" + datos.getCoordinadorTelefonoCasa() + "'";
            }
            if (!datos.getCoordinadorTelefonoCelular().equals("")) {
                label += ",coordinadorTelefonoCelular";
                values += ",'" + datos.getCoordinadorTelefonoCelular() + "'";
            }
            if (!datos.getDirectorNombre().isEmpty()) {
                label += ",directorNombre";
                values += ",'" + datos.getDirectorNombre() + "'";
            }
            if (!datos.getDirectorCorreo().isEmpty()) {
                label += ",directorCorreo";
                values += ",'" + datos.getDirectorCorreo() + "'";
            }
            if (!datos.getDirectorTelefonoCasa().equals("")) {
                label += ",directorTelefonoCasa";
                values += ",'" + datos.getDirectorTelefonoCasa() + "'";
            }
            if (!datos.getDirectorTelefonoCelular().equals("")) {
                label += ",directorTelefonoCelular";
                values += ",'" + datos.getDirectorTelefonoCelular() + "'";
            }
            label += ") ";
            values += ") ";
            sql += label + values;
//      datos.setMensaje(sql);
            Statement stmt = conexion.createStatement();
            rs = stmt.executeUpdate(sql);

        } catch (SQLException s) {
        }
        return rs > 0;
    }

    public boolean agregarInstitucionDatosSituacion(InstitucionDatosSituacion datos) {
        int rs = 0;
        try {
            String sql = "INSERT INTO \"PIO\".instituciondatossituacion ";
            String label = "(institucionid";
            String values = "VALUES ('" + datos.getInstitucionId() + "'";
            if (!datos.getObservacionesPlanta().isEmpty()) {
                label += ",observacionesplanta";
                values += ",'" + datos.getObservacionesPlanta() + "'";
            }
            if (!datos.getAsignaturasAusenciaProfesores().isEmpty()) {
                label += ",asignaturasAusenciaProfesores";
                values += ",'" + datos.getAsignaturasAusenciaProfesores() + "'";
            }
            label += ",asignaturasAusenciaNivel7,asignaturasAusenciaNivel8,"
                    + "asignaturasAusenciaNivel9,asignaturasAusenciaNivel4,"
                    + "asignaturasAusenciaNivel5,asignaturasAusenciaNivel6";
            values += ",'" + datos.getAsignaturasAusenciaNivel7() + "'";
            values += ",'" + datos.getAsignaturasAusenciaNivel8() + "'";
            values += ",'" + datos.getAsignaturasAusenciaNivel9() + "'";
            values += ",'" + datos.getAsignaturasAusenciaNivel4() + "'";
            values += ",'" + datos.getAsignaturasAusenciaNivel5() + "'";
            values += ",'" + datos.getAsignaturasAusenciaNivel6() + "'";
            if (!datos.getMotivoAusenciaProfesores().isEmpty()) {
                label += ",motivoAusenciaProfesores";
                values += ",'" + datos.getMotivoAusenciaProfesores() + "'";
            }
            if (!datos.getMatriculaInstitucion().isEmpty()) {
                label += ",matriculaInstitucion";
                values += ",'" + datos.getMatriculaInstitucion() + "'";
            }
            if (!datos.getNroAsistenciaCharla().isEmpty()) {
                label += ",nroAsistenciaCharla";
                values += ",'" + datos.getNroAsistenciaCharla() + "'";
            }
            if (!datos.getEmbarazosTotal().isEmpty()) {
                label += ",embarazosTotal";
                values += ",'" + datos.getEmbarazosTotal() + "'";
            }
            if (!datos.getEmbarazos4().isEmpty()) {
                label += ",embarazos4";
                values += ",'" + datos.getEmbarazos4() + "'";
            }
            if (!datos.getEmbarazos5().isEmpty()) {
                label += ",embarazos5";
                values += ",'" + datos.getEmbarazos5() + "'";
            }
            if (!datos.getEmbarazos6().isEmpty()) {
                label += ",embarazos6";
                values += ",'" + datos.getEmbarazos6() + "'";
            }
            if (!datos.getEmbarazos7().isEmpty()) {
                label += ",embarazos7";
                values += ",'" + datos.getEmbarazos7() + "'";
            }
            if (!datos.getEmbarazos8().isEmpty()) {
                label += ",embarazos8";
                values += ",'" + datos.getEmbarazos8() + "'";
            }
            if (!datos.getEmbarazos9().isEmpty()) {
                label += ",embarazos9";
                values += ",'" + datos.getEmbarazos9() + "'";
            }
            if (!datos.getEmbarazos12().isEmpty()) {
                label += ",embarazos12";
                values += ",'" + datos.getEmbarazos12() + "'";
            }
            if (!datos.getEmbarazos13().isEmpty()) {
                label += ",embarazos13";
                values += ",'" + datos.getEmbarazos13() + "'";
            }
            if (!datos.getEmbarazos14().isEmpty()) {
                label += ",embarazos14";
                values += ",'" + datos.getEmbarazos14() + "'";
            }
            if (!datos.getEmbarazos15().isEmpty()) {
                label += ",embarazos15";
                values += ",'" + datos.getEmbarazos15() + "'";
            }
            if (!datos.getEmbarazos16().isEmpty()) {
                label += ",embarazos16";
                values += ",'" + datos.getEmbarazos16() + "'";
            }

            if (!datos.getEmbarazos17().isEmpty()) {
                label += ",embarazos17";
                values += ",'" + datos.getEmbarazos17() + "'";
            }
            if (datos.getOrientacionIndividual() != null) {
                label += ",orientacionIndividual";
                values += ",'" + datos.getOrientacionIndividual() + "'";
            }
            if (datos.getOrientacionFamiliar() != null) {
                label += ",orientacionFamiliar";
                values += ",'" + datos.getOrientacionFamiliar() + "'";
            }
            if (!datos.getProgramasRemitidos().isEmpty()) {
                label += ",programasRemitidos";
                values += ",'" + datos.getProgramasRemitidos() + "'";
            }
            if (!datos.getProgramasOPS().isEmpty()) {
                label += ",programasOPS";
                values += ",'" + datos.getProgramasOPS() + "'";
            }
            label += ") ";
            values += ")";
            sql += label + values;
//      datos.setMensaje(sql);
            Statement stmt = conexion.createStatement();
            rs = stmt.executeUpdate(sql);
        } catch (SQLException s) {
        }
        return rs > 0;
    }

    public boolean agregarInstitucionMateriaSinProfesor(InstitucionMateriaSinProfesor datos) {
        int rs = 0;
//    if (!conectar()) {
//      return false;
//    }
        try {
            String sql = "INSERT into \"PIO\".\"InstitucionMateriaSinProfesor\" "
                    + "(\"institucionId\", \"materia\") "
                    + " VALUES ('"
                    + datos.getInstitucionId() + "','"
                    + datos.getMateria() + "')";
            Statement stmt = conexion.createStatement();
            rs = stmt.executeUpdate(sql);
        } catch (SQLException s) {
        }
        return rs > 0;
    }

    public boolean agregarInstitucionMencionDiversificado(InstitucionMencionDiversificado datos) {
        int rs = 0;
        try {
            String sql = "INSERT into \"PIO\".institucionmenciondiversificado "
                    + "(institucionId, mencion) "
                    + " VALUES ('"
                    + datos.getInstitucionId() + "','"
                    + datos.getMencion() + "')";
            Statement stmt = conexion.createStatement();
            rs = stmt.executeUpdate(sql);
        } catch (SQLException s) {
        }
        return rs > 0;
    }

    public boolean agregarInstitucionNivelAusencia(InstitucionNivelAusencia datos) {
        int rs = 0;
//    if (!conectar()) {
//      return false;
//    }
        try {
            String sql = "INSERT into \"PIO\".\"InstitucionNivelAusencia\" "
                    + "(\"institucionId\", \"nivel\") "
                    + " VALUES ('"
                    + datos.getInstitucionId() + "','"
                    + datos.getNivel() + "')";
            Statement stmt = conexion.createStatement();
            rs = stmt.executeUpdate(sql);
        } catch (SQLException s) {
        }
        return rs > 0;
    }

    public boolean agregarInstitucionServicio(InstitucionServicio datos) {
        int rs = 0;
//    if (!conectar()) {
//      return false;
//    }
        try {
            String sql = "INSERT into \"PIO\".\"InstitucionServicio\" "
                    + "(\"institucionId\", \"tipo\", \"cantidad\", \"calidad\" ) "
                    + " VALUES ('"
                    + datos.getInstitucionId() + "','"
                    + datos.getTipo() + "','"
                    + datos.getCantidad() + "','"
                    + datos.getCalidad() + "')";
            Statement stmt = conexion.createStatement();
            rs = stmt.executeUpdate(sql);
        } catch (SQLException s) {
        }
        return rs > 0;
    }

    /*
     * public boolean agregarPreinscrito(Preinscrito alumno) { int rs = 0; if
     * (!conectar()) { return false; } try { String sql = "INSERT into
     * \"PIO\".preinscrito " + "(cedula, opcion1, opcion2, opcion3) " + "VALUES
     * ('" + alumno.getCedula() + "','" + alumno.getOpcion1() + "','" +
     * alumno.getOpcion2() + "','" + alumno.getOpcion3() + "')";
     *
     * Statement stmt = conexion.createStatement(); rs =
     * stmt.executeUpdate(sql); } catch (SQLException s) { } return rs > 0; }
     */
    public boolean agregarInstitucionDatosViolencia(InstitucionDatosViolencia datos) {
        int rs = 0;
//    if (!conectar()) {
//      return false;
//    }
        try {
            String sql = "INSERT into \"PIO\".instituciondatosviolencia ";
            String label = "(institucionId";
            String values = " VALUES ('" + datos.getInstitucionId() + "'";

            if (!datos.getFisicaEvidenteConsecuencias().isEmpty()) {
                label += ",fisicaEvidenteConsecuencias";
                values += ",'" + datos.getFisicaEvidenteConsecuencias() + "'";
            }
            if (!datos.getFisicaArmasBlancasConsecuencias().isEmpty()) {
                label += ",fisicaArmasBlancasConsecuencias";
                values += ",'" + datos.getFisicaArmasBlancasConsecuencias() + "'";
            }

            if (!datos.getFisicaArmasFuegoConsecuencias().isEmpty()) {
                label += ",fisicaArmasFuegoConsecuencias";
                values += ",'" + datos.getFisicaArmasFuegoConsecuencias() + "'";
            }

            if (!datos.getFisicaObjetosConsecuencias().isEmpty()) {
                label += ",fisicaObjetosConsecuencias";
                values += ",'" + datos.getFisicaObjetosConsecuencias() + "'";
            }

            label += ",fisicaMayorFrecuenciaNiveles4";
            values += ",'" + datos.getFisicaMayorFrecuenciaNiveles4() + "'";

            label += ",fisicaMayorFrecuenciaNiveles5";
            values += ",'" + datos.getFisicaMayorFrecuenciaNiveles5() + "'";

            label += ",fisicaMayorFrecuenciaNiveles6";
            values += ",'" + datos.getFisicaMayorFrecuenciaNiveles6() + "'";

            label += ",fisicaMayorFrecuenciaNiveles7";
            values += ",'" + datos.getFisicaMayorFrecuenciaNiveles7() + "'";

            label += ",fisicaMayorFrecuenciaNiveles8";
            values += ",'" + datos.getFisicaMayorFrecuenciaNiveles8() + "'";

            label += ",fisicaMayorFrecuenciaNiveles9";
            values += ",'" + datos.getFisicaMayorFrecuenciaNiveles9() + "'";

            if (!datos.getFisicaAccionesTomadas().isEmpty()) {
                label += ",fisicaAccionesTomadas";
                values += ",'" + datos.getFisicaAccionesTomadas() + "'";
            }

            label += ",fisicaCausasEnfrentamientoBandas";
            values += ",'" + datos.getFisicaCausasEnfrentamientoBandas() + "'";

            label += ",fisicaCausasDrogas";
            values += ",'" + datos.getFisicaCausasDrogas() + "'";

            label += ",fisicaCausasSupervivenciaAlMedio";
            values += ",'" + datos.getFisicaCausasSupervivenciaAlMedio() + "'";

            label += ",fisicaCausasDiscusiones";
            values += ",'" + datos.getFisicaCausasDiscusiones() + "'";

            label += ",fisicaCausasEntorno";
            values += ",'" + datos.getFisicaCausasEntorno() + "'";

            label += ",fisicaCausasInfluenciaSocial";
            values += ",'" + datos.getFisicaCausasInfluenciaSocial() + "'";


            if (datos.getFisicaSexoMayorFrecuencia() != null) {
                label += ",fisicaSexoMayorFrecuencia";
                values += ",'" + datos.getFisicaSexoMayorFrecuencia() + "'";
            }

            if (!datos.getFisicaAsistenciaProgramas().isEmpty()) {
                label += ",fisicaAsistenciaProgramas";
                values += ",'" + datos.getFisicaAsistenciaProgramas() + "'";
            }

            if (datos.getFisicaRegistro() != null) {
                label += ",fisicaRegistro";
                values += ",'" + datos.getFisicaRegistro() + "'";
            }

            if (datos.getVerbalInsultos() != null) {
                label += ",verbalInsultos";
                values += ",'" + datos.getVerbalInsultos() + "'";
            }

            if (datos.getVerbalMalasPalabras() != null) {
                label += ",verbalMalasPalabras";
                values += ",'" + datos.getVerbalMalasPalabras() + "'";
            }

            if (datos.getVerbalGritosAlteracion() != null) {
                label += ",verbalGritosAlteracion";
                values += ",'" + datos.getVerbalGritosAlteracion() + "'";
            }

            if (datos.getVerbalDescalificaciones() != null) {
                label += ",verbalDescalificaciones";
                values += ",'" + datos.getVerbalDescalificaciones() + "'";
            }

            if (!datos.getVerbalMedidasInterestudiantiles().isEmpty()) {
                label += ",verbalMedidasInterestudiantiles";
                values += ",'" + datos.getVerbalMedidasInterestudiantiles() + "'";
            }

            if (!datos.getVerbalMedidasProfesores().isEmpty()) {
                label += ",verbalMedidasProfesores";
                values += ",'" + datos.getVerbalMedidasProfesores() + "'";
            }

            label += ",verbalAdministrativo";
            values += ",'" + datos.getVerbalAdministrativo() + "'";

            label += ",verbalObrero";
            values += ",'" + datos.getVerbalObrero() + "'";

            if (!datos.getVerbalMedidasOtros().isEmpty()) {
                label += ",verbalMedidasOtros";
                values += ",'" + datos.getVerbalMedidasOtros() + "'";
            }

            label += ",destruccionPupitres";
            values += ",'" + datos.getDestruccionPupitres() + "'";


            label += ",rayarParedes";
            values += ",'" + datos.getRayarParedes() + "'";


            label += ",materialInstitucional";
            values += ",'" + datos.getMaterialInstitucional() + "'";

            label += ",banos";
            values += ",'" + datos.getBanos() + "'";

            label += ",bebederos";
            values += ",'" + datos.getBebederos() + "'";

            label += ")";
            values += ") ";
            sql += label + values;
            datos.setMensaje(sql);
            Statement stmt = conexion.createStatement();
            rs = stmt.executeUpdate(sql);
        } catch (SQLException s) {
        }
        return rs > 0;
    }

    public List consultarCarreras() {
        ArrayList listaCarreras = new ArrayList();
//    if (!conectar()) {
//      return listaCarreras;
//    }
        try {
            String sqlquery = "SELECT * "
                    + "FROM \"PIO\".carrera "
                    + "ORDER BY codigo";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                Carrera temp = new Carrera();
                temp.setId(rs.getInt("codigo"));
                temp.setNombre(rs.getString("nombre"));
                listaCarreras.add(temp);
            }
        } catch (SQLException s) {
        }
        return listaCarreras;

    }

//    public boolean modificarPreinscrito(Preinscrito inscrito) {
//
//        boolean modificado = modificarAspirante((Aspirante) inscrito);
//        if (!modificado) {
//            return false;
//        }
//
////        if (!conectar() ) 
////        {
////           return true;
////        }
//
//        try {
//            String sqlquery = "UPDATE \"PIO\".\"preinscrito\" ";
//            boolean hayparam = false;
//            if (inscrito.getOpcion1() != 0) {
//                if (hayparam) {
//                    sqlquery = sqlquery + ", opcion1 = '" + inscrito.getOpcion1() + "'";
//                } else {
//                    sqlquery = sqlquery + "SET opcion1 = '" + inscrito.getOpcion1() + "'";
//                }
//                hayparam = true;
//            }
//
//            if (inscrito.getOpcion2() != 0) {
//                if (hayparam) {
//                    sqlquery = sqlquery + ",opcion2 = '" + inscrito.getOpcion2() + "'";
//                } else {
//                    sqlquery = sqlquery + "SET opcion2 = '" + inscrito.getOpcion2() + "'";
//                }
//                hayparam = true;
//            }
//
//            if (inscrito.getOpcion2() != 0) {
//                if (hayparam) {
//                    sqlquery = sqlquery + ",opcion3 = '" + inscrito.getOpcion3() + "'";
//                } else {
//                    sqlquery = sqlquery + "SET opcion3 = '" + inscrito.getOpcion3() + "'";
//                }
//                hayparam = true;
//            }
//            sqlquery = sqlquery + "WHERE cedula = '" + inscrito.getCedula() + "'";
//            Statement stmt = conexion.createStatement();
//            return stmt.executeUpdate(sqlquery) > 0;
//        } catch (SQLException s) {
//        }
//        return true;
//
//    }
    public ArrayList consultarMencionesDiversificado(InstitucionMencionDiversificado mencion) {
        ArrayList listaMenciones = new ArrayList();
        try {
            String sqlquery = "SELECT * "
                    + "FROM \"PIO\".InstitucionMencionDiversificado "
                    + "WHERE institucionId = '" + mencion.getInstitucionId() + "'";
//      mencion.setMensaje(sqlquery);
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                String temp = rs.getString("mencion");
                listaMenciones.add(temp);
            }
        } catch (SQLException s) {
        }
        return listaMenciones;
    }

    public ArrayList consultarMencionesDiversificado(Institucion mencion) {
        ArrayList listaMenciones = new ArrayList();
        try {
            String sqlquery = "SELECT * "
                    + "FROM \"PIO\".InstitucionMencionDiversificado "
                    + "WHERE institucionId = '" + mencion.getId() + "'";
            System.out.println(sqlquery);
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                String temp = rs.getString("mencion");
                listaMenciones.add(temp);
            }
        } catch (SQLException s) {
        }
        return listaMenciones;
    }

    /**
     * Hace al usuario contenido en 'c' el coordinador de las instituciones que
     * el mismo contiene en getInstituciones(). SI el usuario no existe, el
     * mismo es creado
     *
     * @param c Objeto Coordinador que representa las asociaciones a crear
     * @return True si la operación tuvo éxito, false en caso contrario
     */
    public boolean agregarCoordinador(Coordinador c) {
        int rs = 1;
        boolean continuar = true;
        ResultSet rset;
        Statement st;
        try {
            if (!c.hasValidAtts()) {
                System.out.println("Los atributos del coordinador no son válidos");
                return false;
            }
            String query = "SELECT * FROM \"PIO\".usuario WHERE cedula = '" + c.getCedula() + "'";
            st = conexion.createStatement();
            rset = st.executeQuery(query);
            System.out.println(query);
            if (!rset.next()) {
                continuar = agregarUsuario((Usuario) c) && agregarRegistro((Usuario) c, 5);
            }
            if (continuar) {
                System.out.println("dentro de dbms el tamano de la lista es: " + c.getInstituciones().size());
                for (Institucion i : c.getInstituciones()) {
                    System.out.println("El id de la institucion es: " + i.getId());
                    if (i.getId() != 0) {
                        String sql = "INSERT INTO \"PIO\".coordinador"
                                + "(cedula, institucionid) "
                                + "VALUES ('"
                                + c.getCedula() + "',"
                                + i.getId() + ")";
                        System.out.println(sql);
                        rs += st.executeUpdate(sql);
                    }
                }
            } else {
                System.out.println("Se agrego el usuario pero no el registro");
                // Se agrego el usuario pero no el registro
                eliminarUsuario(c);
            }
        } catch (SQLException s) {
            System.out.println(s.getMessage());
            return false;
        }
        return rs > 0;
    }

    /**
     * Elimina al coordinador que posee la misma cédula que 'c' de la base de
     * datos. También elimina sus datos como usuario del sistema
     *
     * @param c Objeto Coordinador con la información del coordinador a eliminar
     * @return True si la operación tuvo éxito, false en caso contrario
     */
    public boolean eliminarCoordinador(Coordinador c) {
        int eliminados = 0;
        boolean isFirst = true;
        String endVal = "";
        try {
            String sqlquery = "DELETE FROM \"PIO\".coordinador WHERE "
                    + "cedula = '" + c.getCedula() + "'";
            for (Institucion i : c.getInstituciones()) {
                if (isFirst) {
                    sqlquery += " AND(institucionId = " + i.getId();
                    isFirst = false;
                    endVal = ")";
                } else {
                    sqlquery += " OR institucionId = " + i.getId();
                }
            }
            sqlquery += endVal;
            System.out.println(sqlquery);
            Statement s = conexion.createStatement();
            eliminados = s.executeUpdate(sqlquery);
        } catch (SQLException s) {
            return false;
        }
        return (eliminados > 0);
    }

    /**
     * Método que modifica los datos del coordinador indicado en 'c'
     *
     * @param c Objeto Coordinador con los datos del coordinador a modificar
     * @return True si la modificación se hizo correctamente, false en caso
     * contrario
     */
    public boolean modificarCoordinador(Coordinador c) {
        return this.modificarUsuario(c);
    }

    public ArrayList consultarUsuario(Usuario u) {
        ArrayList usuarios = new ArrayList();
        try {
            String sqlquery = "SELECT * "
                    + "FROM \"PIO\".usuario "
                    + (!u.consultar().equals("") ? " WHERE " + u.consultar() : "")
                    + "ORDER BY cedula ";
            System.out.println(sqlquery);
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                usuarios.add(new Usuario(rs.getString("cedula"),
                        rs.getString("nombres"), rs.getString("apellidos"), rs.getString("sexo"),
                        rs.getString("correo"), rs.getString("telefonoCasa"), rs.getString("telefonoCelular"), rs.getString("direccion"), rs.getString("nacionalidad"), rs.getString("fechaNacimiento")));
            }
        } catch (SQLException s) {
            System.out.println(s);
        }
        return usuarios;
    }

    /**
     * Método que utiliza la instancia contenida en 'c' para generar una
     * consulta sobre la tabla de coordinadores.
     *
     * @param c Objeto Coordinador que contiene la consulta a realizar.
     * @return Todos los coordinadores que coincidieron con la consulta
     * realizada.
     */
    public ArrayList consultarCoordinador(Coordinador c) {
        ArrayList<Coordinador> coordinadores = new ArrayList();
        String sqlquery;
        Institucion i;
        try {
            sqlquery = "SELECT * FROM \"PIO\".usuario u WHERE EXISTS(SELECT * FROM"
                    + "\"PIO\".registro r WHERE u.cedula = r.cedula AND r.rol = 5)";
            if (c.getInstituciones().size() > 0) {
                i = c.getInstituciones().get(0);
                sqlquery += " AND EXISTS(SELECT * FROM \"PIO\".coordinador c WHERE"
                        + " c.cedula = u.cedula AND c.institucionId = " + i.getId()
                        + ")";
            }
            String condicionUsuario = construirCondicionUsuario(c, false);

            if (!condicionUsuario.isEmpty()) {
                sqlquery += " " + condicionUsuario;
            }

            System.out.println("Consulta: " + sqlquery);
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                System.out.println("Agregando coordinador a la consulta");
                Coordinador cord = new Coordinador();
                this.setAtts(cord, rs);
                coordinadores.add(cord);
            }

            for (Coordinador co : coordinadores) {
                sqlquery = "SELECT * FROM \"PIO\".institucion i WHERE EXISTS("
                        + "SELECT * FROM \"PIO\".coordinador c WHERE c.institucionId = "
                        + "i.id AND c.cedula = '" + co.getCedula() + "')";
                rs = stmt.executeQuery(sqlquery);
                while (rs.next()) {
                    i = new Institucion();
                    i.setId(rs.getInt("id"));
                    i.setNombre(rs.getString("nombre"));
                    co.agregarInstitucion(i);
                }
            }
        } catch (SQLException s) {
            System.out.println(s);
            return new ArrayList<Coordinador>();
        }
        return coordinadores;
    }

    /**
     * Método para agregar el contenido de un objeto Aula a la base de datos
     *
     * @param aula Objeto de tipo Aula que contiene la información a agreagar
     * @return True si se agregó el objeto con éxito, false en caso contrario
     */
    public boolean agregarAula(Aula aula) {
        int agregados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            String query = "INSERT INTO \"PIO\".aula(ubicacion, capacidad, sede) "
                    + "VALUES("
                    + "'" + aula.getUbicacion()
                    + "', " + aula.getCapacidad()
                    + ", '" + aula.getSede() + "'"
                    + ")";

            System.out.println(query);
            Statement st = conexion.createStatement();
            agregados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }

        return agregados > 0;
    }

    /**
     * Método para eliminar el aula indicada de la base de datos
     *
     * @param aula Objeto Aula que contiene la información del aula a eliminar
     * @return True si se eliminó exitosamente, false en caso contrario
     */
    public boolean eliminarAula(Aula aula) {
        String query;
        Statement st;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            query = "DELETE FROM \"PIO\".aula WHERE ubicacion = "
                    + "'" + aula.getUbicacion() + "'";

            System.out.println(query);
            st = conexion.createStatement();
            st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println("Excepcion: " + se.getMessage());
            return false;
        }

        return true;
    }

    /**
     * Método para modificar la información del aula indicada. Se asume que los
     * parámetros que vienen con string vacío, o null, o -1, no se desean
     * modificar
     *
     * @param aula Objeto Aula con la información del aula que se desea
     * modificar
     * @return true si la modificación tuvo éxito, false en caso contrario
     */
    public boolean modificarAula(Aula aula) {
        String query;
        Statement st;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            query = "UPDATE \"PIO\".aula";

            if (null != aula.getCapacidad()) {
                query += " SET capacidad = " + aula.getCapacidad();
                isFirst = false;
            }

            if (null != aula.getSede()) {
                if (isFirst) {
                    query += " SET sede = '" + aula.getSede() + "'";
                    isFirst = false;
                } else {
                    query += ", sede = '" + aula.getSede() + "'";
                }
            }
            query += " WHERE ubicacion = '" + aula.getUbicacion() + "'";
            st = conexion.createStatement();
            st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }

        return true;
    }

    /**
     * Método para seleccionar de la base de datos todas las entradas de aulas
     * que posean campos en común con el objeto dado. Se asume que los campos en
     * null o string vacío no desean ser consultados
     *
     * @param aula Objeto Aula que contiene la información a ser consultada
     * @return ArrayList de objetos Aula con los resultados de la búsqueda
     */
    public ArrayList<Aula> consultarAula(Aula aula) {
        ResultSet rs;
        Statement st;
        ArrayList resultado = new ArrayList();
        String query;
        boolean isFirst = true;

        query = "SELECT * FROM \"PIO\".aula";

        if (null != aula.getUbicacion() && !aula.getUbicacion().isEmpty()) {
            query += " WHERE ubicacion = '" + aula.getUbicacion() + "'";
            isFirst = false;
        }

        if (null != aula.getCapacidad()) {
            if (!isFirst) {
                query += " AND capacidad = " + aula.getCapacidad();
            } else {
                query += " WHERE capacidad = " + aula.getCapacidad();
                isFirst = false;
            }
        }

        if (null != aula.getSede()) {
            if (isFirst) {
                query += " WHERE sede = '" + aula.getSede() + "'";
                isFirst = false;
            } else {
                query += " AND sede = '" + aula.getSede() + "'";
            }
        }

        System.out.println(query);
        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return new ArrayList();
            }

            st = conexion.createStatement();
            rs = st.executeQuery(query);

            while (rs.next()) {
                Aula nueva = new Aula();
                nueva.setUbicacion(rs.getString("ubicacion"));
                nueva.setCapacidad(rs.getInt("capacidad"));
                nueva.setSede(rs.getString("sede"));

                resultado.add(nueva);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList();
        }

        return resultado;
    }

    /**
     * Método para agregar carreras a la base de datos
     *
     * @param a Objeto de tipo Carrera que contiene la información a agreagar
     * @return True si se agregó el objeto con éxito, false en caso contrario
     */
    public boolean agregarCarrera(Carrera a) {
        int agregados;
        try {
            String query = "INSERT INTO \"PIO\".carrera(codigo, nombre) "
                    + "VALUES(" + a.getCodigo() + ","
                    + "'" + a.getNombre() + "')";
            Statement st = conexion.createStatement();
            agregados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return agregados > 0;
    }

    /**
     * Método para eliminar la carrera indicada de la base de datos
     *
     * @param a Objeto Carrera que contiene la información de la carrera a
     * eliminar se asume que los campos con string null, string "", o -1, no
     * desean ser tomados en cuenta
     * @return True si se eliminó exitosamente, false en caso contrario
     */
    public boolean eliminarCarrera(Carrera a) {
        String query;
        Statement st;
        int eliminados = 0;
        boolean isFirst = true;
        try {
            query = "DELETE FROM \"PIO\".carrera WHERE";
            for (int i = 0; i < 2; ++i) {
                switch (i) {
                    case 0:
                        if (!(null == a.getNombre()
                                || a.getNombre().isEmpty())) {
                            query += " nombre = '" + a.getNombre() + "'";
                            isFirst = false;
                        }
                        break;
                    case 1:
                        if (a.getCodigo() != null && !a.getCodigo().isEmpty()) {
                            if (!isFirst) {
                                query += " AND codigo = " + a.getCodigo();
                            } else {
                                query += " codigo = " + a.getCodigo();
                                isFirst = false;
                            }
                        }
                        break;
                }
            }
            st = DataBaseManager.conexion.createStatement();
            System.out.println(query);
            eliminados = st.executeUpdate(query);

        } catch (SQLException se) {
            System.out.println("Excepcion: " + se.getMessage());
        }
        return eliminados > 0;
    }

    /**
     * Método para modificar la información de la carrera indicada. Se asume que
     * los parámetros que vienen con string vacío, o null, o -1, no se desean
     * modificar
     *
     * @param a Objeto Carrera con la información de la carrera que se desea
     * modificar
     * @return true si la modificación tuvo éxito, false en caso contrario
     */
    public boolean modificarCarrera(Carrera a) {
        String query;
        Statement st;

        try {
            query = "UPDATE \"PIO\".carrera ";
            if (!(null == a.getNombre() || a.getNombre().equals(""))) {
                query += "SET nombre = '" + a.getNombre() + "'";
            }
            query += " WHERE codigo = '" + a.getCodigo() + "'";
            st = conexion.createStatement();
            System.out.println(query);
            st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return true;
    }

    /**
     * Método para seleccionar de la base de datos todas las entradas de
     * carreras que posean campos en común con el objeto dado. Se asume que los
     * campos en null o string vacío o -1 no desean ser consultados
     *
     * @param a Objeto Carrera que contiene la información a ser consultada
     * @return ArrayList de objetos Carrera con los resultados de la búsqueda
     */
    public ArrayList consultarCarrera(Carrera a) {
        ResultSet rs;
        Statement st;
        ArrayList resultado = new ArrayList();
        String query;
        boolean isFirst = true;
        query = "SELECT * FROM \"PIO\".carrera";
        for (int i = 0; i < 2; ++i) {
            switch (i) {
                case 0:
                    if (!(null == a.getNombre()
                            || a.getNombre().equals(""))) {
                        if (isFirst) {
                            query += " WHERE ";
                        }
                        query += " nombre = \'" + a.getNombre() + "\'";
                        isFirst = false;
                    }
                    break;
                case 1:
                    if (!(a.getCodigo() == null || a.getCodigo().isEmpty())) {
                        if (!isFirst) {
                            query += " AND codigo = \'" + a.getCodigo() + "\'";
                        } else {
                            query += " WHERE codigo = \'" + a.getCodigo() + "\'";
                            isFirst = false;
                        }
                    }
                    break;
            }
        }
        try {
            st = conexion.createStatement();
            System.out.println(query);
            rs = st.executeQuery(query);

            while (rs.next()) {
                Carrera nueva = new Carrera();
                nueva.setCodigo(rs.getString("codigo"));
                nueva.setNombre(rs.getString("nombre"));
                resultado.add(nueva);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList();
        }
        return resultado;
    }

    /**
     * Método para agregar el contenido de un objeto Participante a la base de
     * datos
     *
     * @param a Objeto de tipo Participante que contiene la información a
     * agreagar
     * @return True si se agregó el objeto con éxito, false en caso contrario
     */
    public boolean agregarParticipante(Participante a) {
        int agregados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            String query = "INSERT INTO \"PIO\".participante(cedula, numeroInscripcion, "
                    + "fechaInscripcion, representanteCedula) "
                    + "VALUES('" + a.getCedula() + "',"
                    + "'" + a.getNumeroInscripcion() + "', "
                    + "'" + a.getFechaInscripcion() + "', "
                    + "'" + a.getRepresentanteCedula() + "')";

            Statement st = conexion.createStatement();
            agregados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }

        return agregados > 0;
    }

    /**
     * Método para eliminar al participante indicado de la base de datos
     *
     * @param a Objeto Participante que contiene la información del participante
     * a eliminar se asume que los campos con string null, string "", o -1, no
     * desean ser tomados en cuenta
     * @return True si se eliminó exitosamente, false en caso contrario
     */
    public boolean eliminarParticipante(Participante a) {
        String query;
        Statement st;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            query = "DELETE FROM \"PIO\".usuario u WHERE true";

            for (int i = 0; i < 3; ++i) {
                switch (i) {
                    case 0:
                        if (!(0 == a.getNumeroInscripcion())) {
                            query += " AND EXISTS( SELECT * FROM \"PIO\".participante p"
                                    + " WHERE p.numeroInscripcion = " + a.getNumeroInscripcion() + " AND"
                                    + " p.cedula = u.cedula)";
                        }
                        break;
                    case 1:
                        if ((null != a.getFechaInscripcion()) && !a.getFechaInscripcion().isEmpty()) {
                            query += " AND EXISTS( SELECT * FROM \"PIO\".participante p"
                                    + " WHERE fechaInscripcion = '" + a.getFechaInscripcion() + "' AND"
                                    + " p.cedula = u.cedula)";
                        }
                        break;
                    case 2:
                        if ((null != a.getRepresentanteCedula()) && !a.getRepresentanteCedula().isEmpty()) {
                            query += " AND EXISTS( SELECT * FROM \"PIO\".participante p"
                                    + " WHERE representanteCedula = '" + a.getRepresentanteCedula() + "' AND"
                                    + " p.cedula = u.cedula)";
                        }
                        break;
                    case 3:
                        if (!((null == a.getCedula()) || a.getCedula().isEmpty())) {
                            query += " AND EXISTS(SELECT * FROM \"PIO\".participante p"
                                    + " WHERE p.cedula = '" + a.getCedula() + "' AND p.cedula = u.cedula)";
                        }
                }
            }

            st = conexion.createStatement();
            st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println("Excepcion: " + se.getMessage());
            return false;
        }

        return true;
    }

    /**
     * Método para modificar la información del Participante indicado. Se asume
     * que los parámetros que vienen con string vacío, o null, o -1, no se
     * desean modificar
     *
     * @param a Objeto Participante con la información de la carrera que se
     * desea modificar
     * @return true si la modificación tuvo éxito, false en caso contrario
     */
    public boolean modificarParticipante(Participante a) {

        /*
         * if (!this.modificarPreinscrito(a)) { System.out.println("No se pudo
         * hacer la modficación del preinscrito"); return false; }
         */

        String query;
        Statement st;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            query = "UPDATE \"PIO\".participante ";
            for (int i = 0; i < 3; ++i) {
                switch (i) {
                    case 0:
                        if (!((null == a.getFechaInscripcion()) || a.getFechaInscripcion().isEmpty())) {
                            if (isFirst) {
                                query += "SET fechaInscripcion = '" + a.getFechaInscripcion() + "'";
                                isFirst = false;
                            } else {
                                query += ", fechaInscripcion = '" + a.getFechaInscripcion() + "'";
                            }
                        }
                        break;
                    case 1:
                        if (!((null == a.getRepresentanteCedula()) || a.getRepresentanteCedula().isEmpty())) {
                            if (isFirst) {
                                query += "SET representanteCedula = '" + a.getRepresentanteCedula() + "'";
                                isFirst = false;
                            } else {
                                query += ", representanteCedula = '" + a.getRepresentanteCedula() + "'";
                            }
                        }
                        break;
                    case 2:
                        if (0 != a.getNumeroInscripcion()) {
                            if (isFirst) {
                                query += "SET numeroInscripcion = " + a.getNumeroInscripcion();
                                isFirst = false;
                            } else {
                                query += ", numeroInscripcion = " + a.getNumeroInscripcion();
                            }
                        }
                        break;
                }
            }

            query += " WHERE cedula = '" + a.getCedula() + "'";
            st = conexion.createStatement();
            st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }

        return true;
    }

    /**
     * Método para seleccionar de la base de datos todas las entradas de
     * participante que posean campos en común con el objeto dado. Se asume que
     * los campos en null o string vacío o -1 no desean ser consultados
     *
     * @param a Objeto Participante que contiene la información a ser consultada
     * @return ArrayList de objetos Participante con los resultados de la
     * búsqueda
     */
    public ArrayList consultarParticipante(Participante a) {
        ResultSet rs;
        Statement st;
        ArrayList resultado = new ArrayList();
        String query;
        boolean isFirst = true;

        query = "SELECT * FROM \"PIO\".participante NATURAL JOIN ("
                + "\"PIO\".preinscrito NATURAL JOIN ("
                + "\"PIO\".aspirante NATURAL JOIN "
                + "\"PIO\".usuario)) WHERE";

        for (int i = 0; i < 3; ++i) {
            switch (i) {
                case 0:
                    if (!((null == a.getFechaInscripcion()) || a.getFechaInscripcion().isEmpty())) {
                        if (isFirst) {
                            query += " fechaInscripcion = '" + a.getFechaInscripcion() + "'";
                            isFirst = false;
                        } else {
                            query += " AND fechaInscripcion = '" + a.getFechaInscripcion() + "'";
                        }
                    }
                    break;
                case 1:
                    if (!((null == a.getRepresentanteCedula()) || a.getRepresentanteCedula().isEmpty())) {
                        if (isFirst) {
                            query += " representanteCedula = '" + a.getRepresentanteCedula() + "'";
                            isFirst = false;
                        } else {
                            query += " AND representanteCedula = '" + a.getRepresentanteCedula() + "'";
                        }
                    }
                    break;
                case 2:
                    if (!(0 == a.getNumeroInscripcion())) {
                        if (isFirst) {
                            query += " numeroInscripcion = '" + a.getNumeroInscripcion() + "'";
                            isFirst = false;
                        } else {
                            query += " AND numeroInscripcion = '" + a.getNumeroInscripcion() + "'";
                        }
                    }
            }
        }

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return new ArrayList();
            }

            st = conexion.createStatement();
            rs = st.executeQuery(query);

            while (rs.next()) {
                Participante nueva = new Participante();

                //Atributos de Usuario
                nueva.setCedula(rs.getString("cedula"));
                nueva.setNombres(rs.getString("nombres"));
                nueva.setApellidos(rs.getString("apellidos"));
                nueva.setSexo(rs.getString("sexo"));
                nueva.setCorreo(rs.getString("correo"));
                nueva.setDireccion(rs.getString("direccion"));
                nueva.setFechaNacimiento(rs.getString("fechaNacimiento"));
                nueva.setTelefonoCasa(rs.getString("telefonoCasa"));
                nueva.setTelefonoCelular(rs.getString("telefonoCelular"));
                nueva.setNacionalidad(rs.getString("nacionalidad"));

                //Atributos de Aspirante
                nueva.setInstitucionId(rs.getInt("institucionId"));
                nueva.setPromedio(rs.getDouble("promedio"));

                //Atributos de Preincrito
//                nueva.setNumeroPreinscripcion(rs.getInt("numeroPreinscripcion"));
//                nueva.setFechaPreinscripcion(rs.getString("fechaPreinscripcion"));
//                nueva.setOpcion1(rs.getInt("opcion1"));
//                nueva.setOpcion2(rs.getInt("opcion2"));
//                nueva.setOpcion3(rs.getInt("opcion3"));
//                nueva.setAulaPrueba(rs.getString("aulaPrueba"));
                nueva.setNotaPio(rs.getInt("notaPio"));
                nueva.setNotaRaven(rs.getInt("notaRaven"));

                //Atributos de Participante
                nueva.setNumeroInscripcion(rs.getInt("numeroInscripcion"));
                nueva.setFechaInscripcion(rs.getString("fechaInscripcion"));
                nueva.setRepresentanteCedula(rs.getString("representanteCedula"));
                resultado.add(nueva);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList();
        }

        return resultado;
    }

    /**
     * Método para agregar el contenido de un objeto Periodo a la base de datos
     *
     * @param a Objeto de tipo Periodo que contiene la información a agregar
     * @return True si se agregó el objeto con éxito, false en caso contrario
     */
    public boolean agregarPeriodo(Periodo a) {
        int agregados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            String query = "INSERT INTO \"PIO\".periodo(fechaInicioInscripcion,"
                    + "fechaCierreInscripcion, fechaInicioPreinscripcion, "
                    + "fechaCierrePreinscripcion, fechaPruebas, fechaPublicacionResultadosVocacional) "
                    + "VALUES('" + a.getFechaInicioInscripcion() + "',"
                    + "'" + a.getFechaCierreInscripcion() + "',"
                    + "'" + a.getFechaInicioPreinscripcion() + "',"
                    + "'" + a.getFechaCierrePreinscripcion() + "',"
                    + "'" + a.getFechaPruebas() + "', "
                    + "'" + a.getFechaPublicacionResultadosVocacional() + "')";

            Statement st = conexion.createStatement();
            agregados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }

        return agregados > 0;
    }

    /**
     * Método para eliminar el periodo indicado de la base de datos
     *
     * @param a Objeto Periodo que contiene la información de la carrera a
     * eliminar se asume que los campos con string null, string "", o -1, no
     * desean ser tomados en cuenta
     * @return True si se eliminó exitosamente, false en caso contrario
     */
    public boolean eliminarPeriodo(Periodo a) {
        String query;
        Statement st;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            query = "DELETE FROM \"PIO\".periodo WHERE";
            for (int i = 0; i < 7; ++i) {
                switch (i) {
                    case 0:
                        if (!(0 == a.getId())) {
                            if (!isFirst) {
                                query += " AND Id = " + a.getId();
                            } else {
                                query += " Id = " + a.getId();
                                isFirst = false;
                            }
                        }
                        break;
                    case 1:
                        if (!(null == a.getFechaInicioInscripcion()
                                || a.getFechaInicioInscripcion().equals(""))) {
                            if (isFirst) {
                                query += " fechaInicioInscripcion = '" + a.getFechaInicioInscripcion() + "'";
                                isFirst = false;
                            } else {
                                query += " AND fechaInicioInscripcion = '" + a.getFechaInicioInscripcion() + "'";
                            }
                        }
                        break;
                    case 2:
                        if (!(null == a.getFechaCierreInscripcion()
                                || a.getFechaCierreInscripcion().equals(""))) {
                            if (isFirst) {
                                query += " fechaCierreInscripcion = '" + a.getFechaCierreInscripcion() + "'";
                                isFirst = false;
                            } else {
                                query += " AND fechaCierreInscripcion = '" + a.getFechaCierreInscripcion() + "'";
                            }
                        }
                        break;
                    case 3:
                        if (!(null == a.getFechaInicioPreinscripcion()
                                || a.getFechaInicioPreinscripcion().equals(""))) {
                            if (isFirst) {
                                query += " fechaInicioPreinscripcion = '" + a.getFechaInicioPreinscripcion() + "'";
                                isFirst = false;
                            } else {
                                query += " AND fechaInicioPreinscripcion = '" + a.getFechaInicioPreinscripcion() + "'";
                            }
                        }
                        break;
                    case 4:
                        if (!(null == a.getFechaCierrePreinscripcion()
                                || a.getFechaCierrePreinscripcion().equals(""))) {
                            if (isFirst) {
                                query += " fechaCierrePreinscripcion = '" + a.getFechaCierrePreinscripcion() + "'";
                                isFirst = false;
                            } else {
                                query += " AND fechaCierrePreinscripcion = '" + a.getFechaCierrePreinscripcion() + "'";
                            }
                        }
                        break;
                    case 5:
                        if (!(null == a.getFechaPruebas()
                                || a.getFechaPruebas().equals(""))) {
                            if (isFirst) {
                                query += " fechaPruebas = '" + a.getFechaPruebas() + "'";
                                isFirst = false;
                            } else {
                                query += " AND fechaPruebas = '" + a.getFechaPruebas() + "'";
                            }
                        }
                        break;
                    case 6:
                        if (!(null == a.getFechaPublicacionResultadosVocacional()
                                || a.getFechaPublicacionResultadosVocacional().equals(""))) {
                            if (isFirst) {
                                query += " fechaPublicacionResultadosVocacional = '" + a.getFechaPublicacionResultadosVocacional() + "'";
                                isFirst = false;
                            } else {
                                query += " AND fechaPublicacionResultadosVocacional = '" + a.getFechaPublicacionResultadosVocacional() + "'";
                            }
                        }
                }
            }

            st = conexion.createStatement();
            st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println("Excepcion: " + se.getMessage());
            return false;
        }

        return true;
    }

    /**
     * Método para modificar la información del periodo indicado. Se asume que
     * los parámetros que vienen con string vacío, o null, o -1, no se desean
     * modificar
     *
     * @param a Objeto Periodo con la información del periodo que se desea
     * modificar
     * @return true si la modificación tuvo éxito, false en caso contrario
     */
    public boolean modificarPeriodo(Periodo a) {
        String query;
        Statement st;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            query = "UPDATE \"PIO\".periodo ";
            for (int i = 0; i < 8; ++i) {
                switch (i) {
                    case 0:
                        if (!(null == a.getFechaInicioInscripcion()
                                || a.getFechaInicioInscripcion().equals(""))) {
                            if (isFirst) {
                                query += "SET fechaInicioInscripcion = '" + a.getFechaInicioInscripcion() + "'";
                                isFirst = false;
                            } else {
                                query += ", fechaInicioInscripcion = '" + a.getFechaInicioInscripcion() + "'";
                            }
                        }
                        break;
                    case 1:
                        if (!(null == a.getFechaCierreInscripcion()
                                || a.getFechaCierreInscripcion().equals(""))) {
                            if (isFirst) {
                                query += "SET fechaCierreInscripcion = '" + a.getFechaCierreInscripcion() + "'";
                                isFirst = false;
                            } else {
                                query += ", fechaCierreInscripcion = '" + a.getFechaCierreInscripcion() + "'";
                            }
                        }
                        break;
                    case 2:
                        if (!(null == a.getFechaInicioPreinscripcion()
                                || a.getFechaInicioPreinscripcion().equals(""))) {
                            if (isFirst) {
                                query += "SET fechaInicioPreinscripcion = '" + a.getFechaInicioPreinscripcion() + "'";
                                isFirst = false;
                            } else {
                                query += ", fechaInicioPreinscripcion = '" + a.getFechaInicioPreinscripcion() + "'";
                            }
                        }
                        break;
                    case 3:
                        if (!(null == a.getFechaCierrePreinscripcion()
                                || a.getFechaCierrePreinscripcion().equals(""))) {
                            if (isFirst) {
                                query += "SET fechaCierrePreinscripcion = '" + a.getFechaCierrePreinscripcion() + "'";
                                isFirst = false;
                            } else {
                                query += ", fechaCierrePreinscripcion = '" + a.getFechaCierrePreinscripcion() + "'";
                            }
                        }
                        break;
                    case 4:
                        if (!(null == a.getFechaPruebas()
                                || a.getFechaPruebas().equals(""))) {
                            if (isFirst) {
                                query += "SET fechaPruebas = '" + a.getFechaPruebas() + "'";
                                isFirst = false;
                            } else {
                                query += ", fechaPruebas = '" + a.getFechaPruebas() + "'";
                            }
                        }
                        break;
                    case 5:
                        if (!(null == a.getFechaInicioPreseleccion()
                                || a.getFechaInicioPreseleccion().equals(""))) {
                            if (isFirst) {
                                query += "SET fechaInicioPreseleccion = '" + a.getFechaInicioPreseleccion() + "'";
                                isFirst = false;
                            } else {
                                query += " , fechaInicioPreseleccion = '" + a.getFechaInicioPreseleccion() + "'";
                            }
                        }
                        break;
                    case 6:
                        if (!(null == a.getFechaCierrePreseleccion()
                                || a.getFechaCierrePreseleccion().equals(""))) {
                            if (isFirst) {
                                query += "SET fechaCierrePreseleccion = '" + a.getFechaCierrePreseleccion() + "'";
                                isFirst = false;
                            } else {
                                query += " , fechaCierrePreseleccion = '" + a.getFechaCierrePreseleccion() + "'";
                            }
                        }
                        break;
                    case 7:
                        if (!(null == a.getFechaPublicacionResultadosVocacional()
                                || a.getFechaPublicacionResultadosVocacional().equals(""))) {
                            if (isFirst) {
                                query += "SET fechaPublicacionResultadosVocacional = '" + a.getFechaPublicacionResultadosVocacional() + "'";
                                isFirst = false;
                            } else {
                                query += " , fechaPublicacionResultadosVocacional = '" + a.getFechaPublicacionResultadosVocacional() + "'";
                            }
                        }
                }
            }

            query += " WHERE Id = " + a.getId();
            System.out.println(query);
            st = conexion.createStatement();
            st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }

        return true;
    }

    /**
     * Método para seleccionar de la base de datos todas las entradas de
     * periodos que posean campos en común con el objeto dado. Se asume que los
     * campos en null o string vacío o -1 no desean ser consultados
     *
     * @param a Objeto Periodo que contiene la información a ser consultada
     * @return ArrayList de objetos Periodo con los resultados de la búsqueda
     */
    public ArrayList<Periodo> consultarPeriodo(Periodo a) {
        System.out.println("Ingresando a consultar periodo");
        ResultSet rs;
        Statement st;
        ArrayList resultado = new ArrayList();
        String query;
        boolean isFirst = true;

        query = "SELECT * FROM \"PIO\".periodo ";

        for (int i = 0; i < 9; ++i) {
            System.out.println(query);
            switch (i) {
                case 0:
                    if (!(0 == a.getId())) {
                        if (!isFirst) {
                            query += " AND Id = " + a.getId();
                        } else {
                            query += "WHERE Id = " + a.getId();
                            isFirst = false;
                        }
                    }
                    break;
                case 1:
                    if (!(null == a.getFechaInicioInscripcion()
                            || a.getFechaInicioInscripcion().equals(""))) {
                        if (isFirst) {
                            query += "WHERE fechaInicioInscripcion = '" + a.getFechaInicioInscripcion() + "'";
                            isFirst = false;
                        } else {
                            query += " AND fechaInicioInscripcion = '" + a.getFechaInicioInscripcion() + "'";
                        }
                    }
                    break;
                case 2:
                    if (!(null == a.getFechaCierreInscripcion()
                            || a.getFechaCierreInscripcion().equals(""))) {
                        if (isFirst) {
                            query += "WHERE fechaCierreInscripcion = '" + a.getFechaCierreInscripcion() + "'";
                            isFirst = false;
                        } else {
                            query += " AND fechaCierreInscripcion = '" + a.getFechaCierreInscripcion() + "'";
                        }
                    }
                    break;
                case 3:
                    if (!(null == a.getFechaInicioPreinscripcion()
                            || a.getFechaInicioPreinscripcion().equals(""))) {
                        if (isFirst) {
                            query += "WHERE fechaInicioPreinscripcion = '" + a.getFechaInicioPreinscripcion() + "'";
                            isFirst = false;
                        } else {
                            query += " AND fechaInicioPreinscripcion = '" + a.getFechaInicioPreinscripcion() + "'";
                        }
                    }
                    break;
                case 4:
                    if (!(null == a.getFechaCierrePreinscripcion()
                            || a.getFechaCierrePreinscripcion().equals(""))) {
                        if (isFirst) {
                            query += "WHERE fechaCierrePreinscripcion = '" + a.getFechaCierrePreinscripcion() + "'";
                            isFirst = false;
                        } else {
                            query += " AND fechaCierrePreinscripcion = '" + a.getFechaCierrePreinscripcion() + "'";
                        }
                    }
                    break;
                case 5:
                    if (!(null == a.getFechaPruebas()
                            || a.getFechaPruebas().equals(""))) {
                        if (isFirst) {
                            query += "WHERE fechaPruebas = '" + a.getFechaPruebas() + "'";
                            isFirst = false;
                        } else {
                            query += " AND fechaPruebas = '" + a.getFechaPruebas() + "'";
                        }
                    }
                    break;
                case 6:
                    if (!(null == a.getFechaInicioPreseleccion()
                            || a.getFechaInicioPreseleccion().equals(""))) {
                        if (isFirst) {
                            query += "WHERE fechaInicioPreseleccion = '" + a.getFechaInicioPreseleccion() + "'";
                            isFirst = false;
                        } else {
                            query += " AND fechaInicioPreseleccion = '" + a.getFechaInicioPreseleccion() + "'";
                        }
                    }
                    break;
                case 7:
                    if (!(null == a.getFechaCierrePreseleccion()
                            || a.getFechaCierrePreseleccion().equals(""))) {
                        if (isFirst) {
                            query += "WHERE fechaCierrePreseleccion = '" + a.getFechaCierrePreseleccion() + "'";
                            isFirst = false;
                        } else {
                            query += " AND fechaCierrePreseleccion = '" + a.getFechaCierrePreseleccion() + "'";
                        }
                    }
                    break;
                case 8:
                    if (!(null == a.getFechaPublicacionResultadosVocacional()
                            || a.getFechaPublicacionResultadosVocacional().equals(""))) {
                        if (isFirst) {
                            query += "WHERE fechaPublicacionResultadosVocacional = '" + a.getFechaPublicacionResultadosVocacional() + "'";
                            isFirst = false;
                        } else {
                            query += " AND fechaPublicacionResultadosVocacional = '" + a.getFechaPublicacionResultadosVocacional() + "'";
                        }
                    }
            }
        }

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return new ArrayList();
            }
            System.out.println(query);
            st = conexion.createStatement();
            rs = st.executeQuery(query);
            while (rs.next()) {
                Periodo nueva = new Periodo();
                nueva.setId(rs.getInt("Id"));
                nueva.setFechaInicioPreseleccion(rs.getString("fechaInicioPreseleccion"));
                nueva.setFechaCierrePreseleccion(rs.getString("fechaCierrePreseleccion"));
                nueva.setFechaInicioInscripcion(rs.getString("fechaInicioInscripcion"));
                nueva.setFechaCierreInscripcion(rs.getString("fechaCierreInscripcion"));
                nueva.setFechaInicioPreinscripcion(rs.getString("fechaInicioPreinscripcion"));
                nueva.setFechaCierrePreinscripcion(rs.getString("fechaCierrePreinscripcion"));
                nueva.setFechaPruebas(rs.getString("fechaPruebas"));
                nueva.setFechaPublicacionResultadosVocacional(rs.getString("fechapublicacionresultadosvocacional"));

                resultado.add(nueva);
            }
            System.out.println("Termino de agregar el periodo");
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList();
        }

        return resultado;
    }

    /**
     * Método para agregar el contenido de un objeto PublicacionMuroCoordinador
     * a la base de datos
     *
     * @param a Objeto de tipo PublicacionMuroCoordinador que contiene la
     * información a agregar
     * @return True si se agregó el objeto con éxito, false en caso contrario
     */
    public boolean agregarPublicacionMuroCoordinador(PublicacionMuroCoordinador a) {
        int agregados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            String query = "INSERT INTO \"PIO\".publicacionMuroCoordinador(cedulaAdmin,"
                    + "mensaje) VALUES('" + a.getCedulaAdmin() + "',"
                    + "'" + a.getMensaje() + "')";

            Statement st = conexion.createStatement();
            agregados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }

        return agregados > 0;
    }

    /**
     * Método para eliminar la publicacion indicado de la base de datos
     *
     * @param a Objeto PublicacionMuroCoordinador que contiene la información de
     * la publicacion a eliminar se asume que los campos con string null, string
     * "", o 0, no desean ser tomados en cuenta
     * @return True si se eliminó exitosamente, false en caso contrario
     */
    public boolean eliminarPublicacionMuroCoordinador(PublicacionMuroCoordinador a) {
        String query;
        Statement st;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            query = "DELETE FROM \"PIO\".publicacionMuroCoordinador WHERE";
            for (int i = 0; i < 2; ++i) {
                switch (i) {
                    case 0:
                        if (!(null == a.getCedulaAdmin()
                                || a.getCedulaAdmin().equals(""))) {
                            if (isFirst) {
                                query += " cedulaAdmin = '" + a.getCedulaAdmin() + "'";
                                isFirst = false;
                            } else {
                                query += " AND cedulaAdmin = '" + a.getCedulaAdmin() + "'";
                            }
                        }
                        break;
                    case 1:
                        if (!(null == a.getMensaje()
                                || a.getMensaje().equals(""))) {
                            if (isFirst) {
                                query += " mensaje = '" + a.getMensaje() + "'";
                                isFirst = false;
                            } else {
                                query += " AND mensaje = '" + a.getMensaje() + "'";
                            }
                        }
                        break;

                }
            }

            st = conexion.createStatement();
            st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println("Excepcion: " + se.getMessage());
            return false;
        }

        return true;
    }

    /**
     * Método para seleccionar de la base de datos todas las entradas de
     * publicaciones que posean campos en común con el objeto dado. Se asume que
     * los campos en null o string vacío o 0 no desean ser consultados
     *
     * @param a Objeto PublicacionMuroCoordinador que contiene la información a
     * ser consultada
     * @return ArrayList de objetos PublicacionMuroCoordinador con los
     * resultados de la búsqueda
     */
    public ArrayList consultarPublicacionMuroCoordinador(PublicacionMuroCoordinador a) {
        ResultSet rs;
        Statement st;
        ArrayList resultado = new ArrayList();
        String query;
        boolean isFirst = true;

        query = "SELECT * FROM \"PIO\".publicacionMuroCoordinador WHERE";

        for (int i = 0; i < 2; ++i) {
            switch (i) {
                case 0:
                    if (!(null == a.getCedulaAdmin()
                            || a.getCedulaAdmin().equals(""))) {
                        if (isFirst) {
                            query += " cedulaAdmin = '" + a.getCedulaAdmin() + "'";
                            isFirst = false;
                        } else {
                            query += " AND cedulaAdmin = '" + a.getCedulaAdmin() + "'";
                        }
                    }
                    break;
                case 1:
                    if (!(null == a.getMensaje()
                            || a.getMensaje().equals(""))) {
                        if (isFirst) {
                            query += " mensaje = '" + a.getMensaje() + "'";
                            isFirst = false;
                        } else {
                            query += " AND mensaje = '" + a.getMensaje() + "'";
                        }
                    }
                    break;
            }
        }

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return new ArrayList();
            }

            st = conexion.createStatement();
            rs = st.executeQuery(query);

            while (rs.next()) {
                PublicacionMuroCoordinador nueva = new PublicacionMuroCoordinador();
                nueva.setCedulaAdmin(rs.getString("cedulaAdmin"));
                nueva.setMensaje(rs.getString("mensaje"));

                resultado.add(nueva);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList();
        }

        return resultado;
    }

    public boolean aspiranteAprobado(Aspirante a) {
        ArrayList<InstitucionAspirante> set = this.consultarAspirantes(a);
        if (set.size() < 1) {
            return false;
        }
        return set.get(0).getAspirantes().get(0).getPromedio() != null && set.get(0).getAspirantes().get(0).getPromedio() >= 12.5; // El unico aspirante que debe estar
    }

    public boolean llenarAspirante(String cedula, Aspirante a) {
        a.setCedula(cedula);
        ArrayList<InstitucionAspirante> set = this.consultarAspirantes(a);
        a = ((set.size() == 1 && set.get(0).getAspirantes().size() == 1) ? set.get(0).getAspirantes().get(0) : null);
        return a != null;
    }

    public boolean agregarContactoCoordinador(ContactoCoordinador c) {
        int rs = 0;
        try {
            String sql = "INSERT into \"PIO\".contacto_coordinador(idinstitucion, "
                    + "asunto, mensaje, fueLeido) VALUES ('"
                    + c.getInstitucionId() + "','"
                    + c.getAsunto() + "','"
                    + c.getMensajeCoordinador() + "', "
                    + (c.getFueLeido() ? 1 : 0) + ")";
            System.out.println(sql);
            Statement stmt = conexion.createStatement();
            rs = stmt.executeUpdate(sql);
        } catch (SQLException s) {
            System.out.println(s);
        }
        return rs > 0;
    }

    public boolean eliminarContactoCoordinador(ContactoCoordinador c) {
        int eliminados = 0;
        try {
            String sqlquery = "DELETE FROM \"PIO\".contacto_coordinador WHERE "
                    + "id = '" + c.getId() + "'";
            Statement s = conexion.createStatement();
            eliminados = s.executeUpdate(sqlquery);
            System.out.println(sqlquery);
        } catch (SQLException s) {
        }
        return eliminados > 0;
    }

    public ArrayList<ContactoCoordinador> consultarContactoCoordinador(ContactoCoordinador c) {
        ArrayList lista = new ArrayList();
        try {
            String sqlquery = "SELECT * "
                    + "FROM \"PIO\".contacto_coordinador "
                    + "ORDER BY idinstitucion";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            System.out.println(sqlquery);
            while (rs.next()) {
                ContactoCoordinador temp = new ContactoCoordinador();
                temp.setAsunto(rs.getString("asunto"));
                temp.setId(rs.getInt("id"));
                temp.setMensaje(rs.getString("mensaje"));
                temp.setInstitucionId(rs.getInt("idinstitucion"));
                temp.setFueLeido((rs.getInt("fueleido") == 0 ? false : true));
                lista.add(temp);
                System.out.println("Se agrego un contacto");
            }
        } catch (SQLException s) {
            System.out.println(s);
        }
        return lista;
    }

    /**
     * Método para agregar el reporte dado a la base de datos
     *
     * @param r Objeto Reporte con la información a agregar en la base de datos
     *
     * @return True si se agregó exitosamente el reporte, false en caso
     * contrario
     */
    public boolean agregarReporte(Reporte r) {
        int agregados = 0;
        String query = "INSERT INTO \"PIO\".reporte(tipo, numAutenticacion) "
                + "VALUES ('" + r.getTipo() + "', " + r.getNumAutenticacion() + ")";

        System.out.println(query);
        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            Statement st = conexion.createStatement();
            agregados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }

        return agregados > 0;
    }

    /**
     * Método que permite consultar si existe algún reporte con un número de
     * autenticación particular
     *
     * @param num el número de autenticación que se desea consultar
     *
     * @return True si existe un reporte con el número indicado, false en caso
     * contrario
     */
    public boolean existeNumAutenticacion(int num) throws Exception {
        String query = "SELECT * FROM \"PIO\".reporte WHERE numAutenticacion = " + num;
        Statement st;
        ResultSet rs;

        try {
            if (conexion.isClosed()) {
                throw new Exception("La conexión está cerrada");
            }

            st = conexion.createStatement();
            rs = st.executeQuery(query);

            if (rs.next()) {
                return true;
            }

            return false;
        } catch (SQLException se) {
            throw new Exception(se.getMessage());
        }
    }

    /**
     * Método que permite consultar si existe algún reporte con un número de
     * autenticación particular
     *
     * @param num el número de autenticación que se desea consultar
     *
     * @return True si existe un reporte con el número indicado, false en caso
     * contrario
     */
    public int buscarID(int num) throws Exception {
        int id = -1;
        try {
            String sqlquery = "SELECT * FROM \"PIO\".reporte WHERE numAutenticacion = " + num;
            Statement stmt = conexion.createStatement();
            System.out.println(sqlquery);
            ResultSet rs = stmt.executeQuery(sqlquery);
            if (rs.next()) {
                id = rs.getInt("id");
            }
        } catch (SQLException s) {
            System.out.print(s);
        }
        return id;
    }

    public boolean llenarPreinscrito(String cedula, Preinscrito p) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    public Object actualizarRol(String cedula, String string) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    /**
     * Consulta si un coordinador ha modificado sus datos alguna vez
     *
     * @param c Coordinador con cedula a consultar
     * @return true si los datos han sido modificados alguna vez, false en caso
     * contrario
     */
    public boolean haModificado(Usuario u) {
        String sqlquery = "SELECT valido from  \"PIO\".validoDatos WHERE cedula = \'"
                + u.getCedula() + "\'";
        Statement st;
        ResultSet rs;
        boolean valido = false;
        try {
            st = DataBaseManager.conexion.createStatement();
            rs = st.executeQuery(sqlquery);
            valido = rs.next() && rs.getBoolean("valido");
        } catch (SQLException ex) {
            return false;
        }
        return valido;
    }

    /**
     * Actualiza la contrasena de un usuario.
     *
     * @param c Objeto con la cedula del usuario a actualizar, contrasena
     * actual, contraasena nueva y confirmacion.
     * @param b si es true se verifica que la contrasena actual este correcta y
     * que las contrasenas nueva y confirmacion sean iguales. Si b es false se
     * cambia sin ningun tipo de confirmacion. En todo caso la contrasena a
     * guardar es la que se encuentra en el atributo contrasenaNueva.
     * @return true si se cambio con exito, false en caso contrario.
     */
    public boolean actualizarContrasena(Contrasena c, boolean b) {
        String sqlquery = "";
        int valido = 0;
        try {
            System.out.print("Intentando cambiar la contrasena de " + c.getCedula());
            sqlquery = "UPDATE \"PIO\".\"registro\" "
                    + "SET clave = '" + c.getContrasenaNueva() + "' , estado = true WHERE registro.cedula = '"
                    + c.getCedula() + "'";
            String sqlquery2 = "SELECT clave FROM \"PIO\".\"registro\" WHERE registro.cedula =  "
                    + "\'" + c.getCedula() + "\'";
            System.out.println(sqlquery);
            System.out.println(sqlquery2);
            Statement s2 = conexion.createStatement();
            ResultSet rs = s2.executeQuery(sqlquery2);

            if (!b || (rs.next() && rs.getString("clave").equals(c.getContrasenaActual()) && c.hasValidAtts())) {
                Statement s = conexion.createStatement();
                valido = s.executeUpdate(sqlquery);
                System.out.println(sqlquery);
            }
        } catch (SQLException ex) {
            System.out.println(sqlquery);
            System.out.println(ex.getMessage());
        }
        return valido > 0;
    }

    /**
     * Compara las fechas del periodo en que los coordinadores pueden entrar al
     * sistema con la fecha de actual.
     *
     * @return -1 si el periodo valido para sus funciones no ha comenzado. 1 si
     * ya termino. 0 si puede ejecutar sus funciones normalmente
     */
    public int validarPeriodoCoordinador() {
        try {
            String sqlquery = "SELECT fechacierrepreseleccion, fechainiciopreseleccion FROM \"PIO\".periodo";
            GregorianCalendar todayGC = new GregorianCalendar();
            Statement s = conexion.createStatement();
            ResultSet rs = s.executeQuery(sqlquery);
            if (rs.next()) {
                String[] fechaCierre;
                String[] fechaInicio;

                fechaCierre = rs.getString("fechacierrepreseleccion").split("/");
                fechaInicio = rs.getString("fechainiciopreseleccion").split("/");
                GregorianCalendar cierre = new GregorianCalendar(Integer.parseInt(fechaCierre[2].trim()),
                        Integer.parseInt(fechaCierre[1].trim()) - 1, Integer.parseInt(fechaCierre[0].trim()));
                System.out.println(cierre.getTime());
                System.out.println(fechaCierre[0] + fechaCierre[1] + fechaCierre[2]);
                GregorianCalendar inicio = new GregorianCalendar(Integer.parseInt(fechaInicio[2].trim()),
                        Integer.parseInt(fechaInicio[1].trim()) - 1, Integer.parseInt(fechaInicio[0].trim()));
                System.out.println(fechaInicio[0] + fechaInicio[1] + fechaInicio[2]);
                System.out.println(inicio.getTime());
                System.out.println(todayGC.getTime());
                if ((todayGC.before(cierre) && todayGC.after(inicio))
                        || (todayGC.equals(cierre) || todayGC.equals(inicio))) {
                    return 0;
                }
                if (todayGC.before(inicio)) {
                    return -1;
                }
                if (todayGC.after(cierre)) {
                    return 1;
                }
            }
            System.out.println("SALIENDO POR DEFECTO ");
            return 0;
        } catch (SQLException ex) {
            System.out.println(ex.getMessage());
        }
        return 0;
    }

    public List consultarNoPreselectos() {
        ArrayList aspirantes = new ArrayList();
//    if (!conectar()) {
//      return aspirantes;
//    }
        try {
            String sqlquery = "SELECT * "
                    + " FROM \"PIO\".aspirante "
                    + " NATURAL JOIN \"PIO\".usuario "
                    + " WHERE promedio < 12.5 "
                    + " ORDER BY cedula";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            while (rs.next()) {
                aspirantes.add(new Integer(rs.getInt("cedula")));
                aspirantes.add(rs.getString("nombres"));
                aspirantes.add(rs.getString("apellidos"));
            }
        } catch (SQLException s) {
        }
        return aspirantes;
    }

    /**
     * Método usado para agregar objetos Noticia a la base de datos
     *
     * @param n Objeto noticia que contiene la información a ser agregada
     * @return True si se agregó exitosamente la noticia, false en caso
     * contrario
     */
    public boolean agregarNoticia(Noticia n) {
        String query;
        Statement st;
        int agregados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return false;
            }

            query = "INSERT INTO \"PIO\".noticia(titulo, cuerpo, fechaPublicacion, fueleida) VALUES('"
                    + n.getTitulo() + "', '" + n.getCuerpo() + "', '" + this.obtenerFechaActualDB() + "', "
                    + (n.getFueLeida() ? 1 : 0) + ")";

            st = conexion.createStatement();
            agregados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return agregados > 0;
    }

    /**
     * Retorna un ArrayList con todas las noticia.s contenidas en la base de
     * datos, ordenados de forma decreciente
     *
     * @return ArrayList de objetos Noticia que contiene todas las noticias de
     * la base de datos ordenadas de forma decreciente, null en caso de error
     */
    public ArrayList<Noticia> listarNoticias() {
        ArrayList<Noticia> res = new ArrayList<Noticia>();
        String query;
        Statement st;
        ResultSet rs;
        Noticia n;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexione esta cerrada");
                return null;
            }
            query = "SELECT * FROM \"PIO\".noticia ORDER BY fechaPublicacion DESC";
            st = conexion.createStatement();
            rs = st.executeQuery(query);

            while (rs.next()) {
                n = new Noticia();
                n.setTitulo(rs.getString("titulo"));
                n.setCuerpo(rs.getString("cuerpo"));
                n.setId(rs.getInt("id"));
                n.setFueLeida((rs.getInt("fueleida") == 0 ? false : true));

                n.setFechaPublicacion(this.invertirFechaDB(rs.getString("fechaPublicacion")));

                res.add(n);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return null;
        }

        return res;
    }

    /**
     * Elimina la noticia que posee el mismo id que n
     *
     * @param n Noticia que contiene el id de la noticia a eliminar
     * @return True si la operación tuvo exito, false en caso contrario
     */
    public boolean eliminarNoticia(Noticia n) {
        String query;
        Statement st;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return false;
            }

            query = "DELETE FROM \"PIO\".noticia WHERE id = '" + n.getId() + "'";
            st = conexion.createStatement();
            st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return true;
    }

    /**
     * Modifica la noticia identificada con el mismo id que el parámetro, c
     * cambiando todos los valores que no se reciban en null o vacío
     *
     * @param noticia Objeto que contiene los datos a modificar
     * @return true si la modificación tuvo éxito, false en caso contrario
     */
    public boolean modificarNoticia(Noticia n) {
        String query;
        Statement st;
        boolean isFirst = true;
        int modificados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            query = "UPDATE \"PIO\".noticia";

            if ((null != n.getTitulo()) && !n.getTitulo().isEmpty()) {
                if (isFirst) {
                    query += " SET titulo='" + n.getTitulo() + "'";
                    isFirst = false;
                } else {
                    query += ", titulo='" + n.getTitulo() + "'";
                }
            }

            if ((null != n.getFechaPublicacion()) && !n.getFechaPublicacion().isEmpty()) {
                if (isFirst) {
                    query += " SET fechapublicacion='" + n.getFechaPublicacion() + "'";
                    isFirst = false;
                } else {
                    query += ", fechapublicacion='" + n.getFechaPublicacion() + "'";
                }
            }

            if ((null != n.getCuerpo()) && !n.getCuerpo().isEmpty()) {
                if (isFirst) {
                    query += " SET cuerpo='" + n.getCuerpo() + "'";
                    isFirst = false;
                } else {
                    query += ", cuerpo='" + n.getCuerpo() + "'";
                }
            }

            if (null != n.getFueLeida()) {
                if (isFirst) {
                    query += " SET fueleida=" + (n.getFueLeida() ? 1 : 0);
                    isFirst = false;
                } else {
                    query += ", fueleida=" + (n.getFueLeida() ? 1 : 0);
                }
            }

            query += " WHERE id = " + n.getId();
            System.out.println(query);

            st = conexion.createStatement();
            modificados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }

        return modificados > 0;
    }

    /**
     * Agrega la pregunta indicadad en p a la base de datos
     *
     * @param p Objeto Pregunta con la infromación a agregar a la base de datos
     * @return true si la operación tuvo éxito, false en caso contrario
     */
    public boolean agregarPregunta(Pregunta p) {
        String query;
        Statement st;
        int agregados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return false;
            }

            query = "INSERT INTO \"PIO\".pregunta(descripcion, peso, fechaModificacion, numrespuestas)"
                    + "VALUES ('" + p.getDescripcion() + "', '" + p.getPeso() + "', '"
                    + this.obtenerFechaActualDB() + "', " + p.getNumRespuestas() + ")";

            st = conexion.createStatement();
            agregados = st.executeUpdate(query);

            for (Opcion o : p.getOpciones()) {
                agregarOpcion(o);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return agregados > 0;
    }

    /**
     * Método que modifica el peso y la descripcion de la pregunta con id
     * p.getId() y a demás actualiza la fecha de modificación. Se asume que los
     * valores que contengan null, string vacío o -1 no desean ser modificados
     *
     * @param p Objeto Pregunta con la información a ser modificada
     * @return True si se actualizó algún registro, false en caso contrario
     */
    public boolean modificarPregunta(Pregunta p) {
        String query;
        Statement st;
        int modificados;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión estpa cerrada");
                return false;
            }

            query = "UPDATE \"PIO\".pregunta SET";
            if (!(null == p.getDescripcion() || p.getDescripcion().isEmpty())) {
                query += " descripcion = '" + p.getDescripcion() + "'";
                isFirst = false;
            }

            if (!(-1 == p.getPeso())) {
                if (isFirst) {
                    query += " peso = " + p.getPeso();
                    isFirst = false;
                } else {
                    query += ", peso = " + p.getPeso();
                }
            }

            if (!(-1 == p.getNumRespuestas())) {
                if (isFirst) {
                    query += " numrespuestas = " + p.getNumRespuestas();
                    isFirst = false;
                } else {
                    query += ", numrespuestas = " + p.getNumRespuestas();
                }
            }

            if (!isFirst) {
                query += ", fechaModificacion = '" + this.obtenerFechaActualDB()
                        + "' WHERE id = " + p.getPreguntaId();
            }

            st = conexion.createStatement();
            modificados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return modificados > 0;
    }

    /**
     * Método que elimina la pregunta con id p.getPreguntaId() de la base de
     * datos. En consecuencia tambipen se eliminarán todas las opciones
     * asociadas a la pregunta.
     *
     * @param p Objeto Pregunta con la información de la pregunta a eliminar
     * @return True si se eliminó la pregunta, false en caso contrario
     */
    public boolean eliminarPregunta(Pregunta p) {
        String query;
        Statement st;
        int eliminados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return false;
            }

            query = "DELETE FROM \"PIO\".pregunta WHERE id = " + p.getPreguntaId();
            st = conexion.createStatement();
            eliminados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return eliminados > 0;
    }

    /**
     * Metodo para agregar la opcion indicada por 'o' en la base de datos
     *
     * @param o Objeto Opcion a agregar
     * @return true si se agregó exitosamente, false en caso contrario
     */
    public boolean agregarOpcion(Opcion o) {
        String query;
        Statement st;
        int agregados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return false;
            }

            query = "INSERT INTO \"PIO\".opcion(descripcion, correcta, idPregunta, fechaModificacion)"
                    + "VALUES('" + o.getDescripcion() + "', " + (o.getCorrecta() ? 1 : 0) + ", "
                    + o.getPreguntaId() + ", '" + this.obtenerFechaActualDB() + "')";
            System.out.println(query);
            st = conexion.createStatement();
            agregados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return agregados > 0;
    }

    /**
     * Método que modifica la descripcion y el puntaje de la opcion con id
     * o.getId(). A demás actualiza en la base de datos la fecha de modificacion
     * para la misma. Se asume que los valores con null, string vacío o -1 no
     * desean ser modificados
     *
     * @param o Objeto Opcion con los valores de la consulta
     * @return True si se hizo alguna modificación, false en caso contrario
     */
    public boolean modificarOpcion(Opcion o) {
        String query;
        Statement st;
        int modificados;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión estpa cerrada");
                return false;
            }

            query = "UPDATE \"PIO\".opcion SET ";
            if (!(null == o.getDescripcion() || o.getDescripcion().isEmpty())) {
                query += " descripcion = '" + o.getDescripcion() + "'";
                isFirst = false;
            }

            if (!(null == o.getCorrecta())) {
                if (isFirst) {
                    query += "SET correcta = " + (o.getCorrecta() ? 1 : 0);
                    isFirst = false;
                } else {
                    query += ", correcta = " + (o.getCorrecta() ? 1 : 0);
                }
            }

            if (!isFirst) {
                query += ", fechaModificacion = '" + this.obtenerFechaActualDB()
                        + "' WHERE id = " + o.getId();
            }

            System.out.println(query);
            st = conexion.createStatement();
            modificados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return modificados > 0;
    }

    /**
     * Elimina de la base de datos la opcion con id o.getId()
     *
     * @param o Objeto Opcion con la información de la opcion a eliminar
     * @return True si se eliminó con éxito, false en caso contrario
     */
    public boolean eliminarOpcion(Opcion o) {
        String query;
        Statement st;
        int eliminados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return false;
            }

            query = "DELETE FROM \"PIO\".opcion WHERE id = " + o.getId();
            st = conexion.createStatement();
            eliminados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return eliminados > 0;
    }

    /**
     * Método que obtiene de la base de datos todas las preguntas guardadas,
     * junto con sus opciones, y las devuelve en una lista ordenada en forma
     * decreciente según la fecha de modificación, tanto por pregunta, como por
     * opciones de cada pregunta.
     *
     * @return ArrayList ordenado con todas las preguntas de la base de datos,
     * null en caso de error
     */
    public ArrayList<Pregunta> consultarPreguntas() {
        ArrayList<Pregunta> result = new ArrayList<Pregunta>();
        String query;
        Statement st;
        ResultSet rspreg, rsop;
        Pregunta preg;
        Opcion op;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return null;
            }

            query = "SELECT * from \"PIO\".pregunta ORDER BY fechaModificacion DESC";
            st = conexion.createStatement();
            rspreg = st.executeQuery(query);
            while (rspreg.next()) {
                preg = new Pregunta();
                preg.setPreguntaId(rspreg.getInt("id"));
                preg.setDescripcion(rspreg.getString("descripcion"));
                preg.setPeso(rspreg.getInt("peso"));
                preg.setFechaModificacion(this.invertirFechaDB(rspreg.getString("fechaModificacion")));
                preg.setNumRespuestas(rspreg.getInt("numRespuestas"));

                result.add(preg);

            }
            for (Pregunta p : result) {
                query = "SELECT * FROM \"PIO\".opcion WHERE idPregunta = " + p.getPreguntaId()
                        + " ORDER BY fechaModificacion DESC";
                rsop = st.executeQuery(query);
                while (rsop.next()) {
                    op = new Opcion();
                    op.setId(rsop.getInt("id"));
                    op.setPreguntaId(rsop.getInt("idPregunta"));
                    op.setDescripcion(rsop.getString("descripcion"));
                    op.setCorrecta((rsop.getInt("correcta") == 0) ? false : true);
                    op.setFechaModificacion(this.invertirFechaDB(rsop.getString("fechaModificacion")));
                    p.agregarOpcion(op);
                }
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return null;
        }
        return result;
    }

    /**
     * Consulta los aspirantes que pertenecen a las instituciones asociadas al
     * coordinador c
     *
     * @param c
     * @return
     */
    public List<InstitucionAspirante> consultarAspirantes(Coordinador c) {
        String sqlquery = "";
        ArrayList<InstitucionAspirante> result = new ArrayList<InstitucionAspirante>();
        List<Coordinador> coordinadorList = this.consultarCoordinador(c);
        if (coordinadorList != null && !coordinadorList.isEmpty()) {
            c.setInstituciones(coordinadorList.get(0).getInstituciones());
            List<Institucion> inst = c.getInstituciones();
            for (int i = 0; i < inst.size(); i++) {
                try {
                    InstitucionAspirante conAspi = new InstitucionAspirante();
                    conAspi.setNombre(inst.get(i).getNombre());
                    conAspi.setId(inst.get(i).getId());
                    sqlquery = "SELECT * FROM \"PIO\".aspirante NATURAL JOIN \"PIO\".usuario "
                            + "WHERE institucionId = "
                            + "\'" + inst.get(i).getId() + "\'";
                    System.out.println(sqlquery);
                    Statement stmt = conexion.createStatement();
                    ResultSet rs = stmt.executeQuery(sqlquery);
                    ArrayList<Aspirante> listaAspirantes = new ArrayList<Aspirante>();
                    while (rs.next()) {
                        Aspirante a = new Aspirante();
                        this.setAtts(a, rs);
                        a.setInstitucionId(rs.getInt("institucionid"));
                        a.setPromedio(rs.getDouble("promedio"));
                        System.out.println("Se agrego " + a.getCedula());
                        listaAspirantes.add(a);
                    }
                    conAspi.setAspirantes(listaAspirantes);
                    result.add(conAspi);
                    System.out.println("Los aspirantes son: ");
                    for (InstitucionAspirante b : result) {
                        for (Aspirante a : b.getAspirantes()) {
                            System.out.println(a.getCedula());
                        }
                    }
                } catch (SQLException ex) {
                    System.out.println(ex);
                }
            }
        }
        return result;

    }

    /**
     * Consulta las fechas en que el aspirante puede ingresar al sistema y la
     * compara con la fecha actual. Regresa 0 si esta dentro del periodo valido,
     * -1 si no ha empezado y 1 si ya termino.
     *
     * @return
     */
    public int validarPeriodoAspirante() {
        return -1;
    }

    /**
     * Metodo para consultar en la base de datos el promedio de aceptacion del
     * PIO
     *
     * @return
     */
    public double consultarPromedioAceptado() {
        return 12.5;
    }

    /**
     * Metodo que agrega la respuesta de un alumno particular al test vocacional
     * a la base de datos
     *
     * @param v Vocacional Objeto que contiene la respuesta al test del alumno
     * @return true si se agregó correctamente, false en caso contrario
     */
    public boolean agregarVocacional(Vocacional v) {
        String query;
        Statement st;
        int agregados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return false;
            }

            st = conexion.createStatement();

            for (Pregunta p : v.getPreguntas()) {
                for (Opcion o : p.getOpciones()) {
                    if (o.getCorrecta()) {

                        query = "INSERT INTO \"PIO\".vocacional(cedula, idpregunta, idopcion) "
                                + "VALUES('" + v.getCedula() + "', " + p.getPreguntaId() + ", "
                                + o.getId() + ")";
                        System.out.println("Ejecutando query: " + query);
                        agregados = st.executeUpdate(query);

                        if (agregados != 1) {
                            System.out.println(query + "Query no retorno correctamente, eliminando entradas");
                            query = "DELETE FROM \"PIO\".vocacional WHERE cedula = '"
                                    + v.getCedula() + "'";
                            st.executeUpdate(query);
                            return false;
                        }
                    }
                }
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return true;
    }

    /**
     * Metodo que, dado un objeto Vocacional, hace una consulta sobre la base de
     * datos usando dicho objeto como parámetro de búsqueda. Cada elemento
     * representará la solución al test vocacional de un estudiante, en el que
     * cada pregunta contendrá el conjunto de respuestas que el estudiante dio a
     * dicha pregunta.
     *
     * @param v Objeto que contiene la información de la consulta
     * @return ArrayList con los elementos que concuerdan con la consulta
     */
    public ArrayList<Vocacional> consultarVocacional(Vocacional v) {
        String query;
        Statement st;
        ArrayList<Vocacional> res = new ArrayList<Vocacional>(), aux0;
        ArrayList<Pregunta> todasPreg = consultarPreguntas(), pAux;
        ResultSet rs;
        Pregunta p;
        Opcion r;
        Vocacional voc;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return new ArrayList<Vocacional>();
            }
            query = "SELECT * FROM \"PIO\".vocacional";

            if (null != v.getCedula() && !v.getCedula().isEmpty()) {
                query += " WHERE cedula = '" + v.getCedula() + "'";
            }

            query += " ORDER BY cedula ASC, idpregunta ASC, idopcion ASC";

            System.out.println(query);
            st = conexion.createStatement();
            rs = st.executeQuery(query);

            //Se toman los datos del ResultSet
            while (rs.next()) {
                voc = new Vocacional();
                p = new Pregunta();
                r = new Opcion();

                r.setId(rs.getInt("idopcion"));
                p.setPreguntaId(rs.getInt("idpregunta"));
                voc.setCedula(rs.getString("cedula"));

                p.agregarOpcion(r);
                voc.agregarPregunta(p);
                res.add(voc);
            }

            //Se poblan los datos obtenidos con los valores completos
            for (Vocacional vo : res) {
                p = vo.getPreguntas().get(0);
                r = p.getOpciones().get(0);
                for (Pregunta prT : todasPreg) {
                    if (p.getPreguntaId() == prT.getPreguntaId()) {
                        p.setDescripcion(prT.getDescripcion());
                        p.setPeso(prT.getPeso());
                        p.setNumRespuestas(prT.getNumRespuestas());
                        p.setFechaModificacion(prT.getFechaModificacion());

                        for (Opcion op : prT.getOpciones()) {
                            if (r.getId() == op.getId()) {
                                r.setPreguntaId(op.getPreguntaId());
                                r.setDescripcion(op.getDescripcion());
                                r.setCorrecta(op.getCorrecta());
                                r.setFechaModificacion(op.getFechaModificacion());
                                break;
                            }
                        }
                        break;
                    }
                }
            }

            if (res.size() == 1) {
                return res;
            }
            //Se agrupan los datos. Primero se juntan en un solo objeto por estudiante
            aux0 = new ArrayList<Vocacional>();
            voc = res.get(0);
            for (int i = 1; i < res.size(); ++i) {
                System.out.println("revisando la cedula: " + res.get(i).getCedula() + " con"
                        + " la cedula base: " + voc.getCedula());
                if (res.get(i).getCedula().equals(voc.getCedula())) {
                    voc.agregarPregunta(res.get(i).getPreguntas().get(0));
                } else {
                    aux0.add(voc);
                    voc = res.get(i);
                }
            }
            aux0.add(voc);

            //Ahora se procede a agrupar las respuestas a cada pregunta dentro de
            //cada test vocacional. Se puede asumir que fueron agregadas en orden de
            //pregunta.

            for (Vocacional vC : aux0) {
                if (vC.getPreguntas().size() == 1) {
                    continue;
                }

                pAux = new ArrayList<Pregunta>();
                p = vC.getPreguntas().get(0);
                for (int i = 1; i < vC.getPreguntas().size(); ++i) {
                    if (p.getPreguntaId() == vC.getPreguntas().get(i).getPreguntaId()) {
                        p.agregarOpcion(vC.getPreguntas().get(i).getOpciones().get(0));
                    } else {
                        pAux.add(p);
                        p = vC.getPreguntas(i);
                    }
                }
                pAux.add(p);
                vC.setPreguntas(pAux);
            }

            res = aux0;
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList<Vocacional>();
        }
        return res;
    }

    /**
     * Retorna un array list con un Email que representan las credenciales de
     * acceso al correo del PIO
     *
     * @param p Entrada 'dummy', ya que solo se tiene un email en la base de
     * datos
     * @return Un ArrayList en el que el primer elemento es el email del pio y
     * el segundo elemento es la contraseña. ArrayList vacío en caso de error
     */
    public ArrayList<Email> consultarEmail(Email p) {
        ArrayList<Email> result = new ArrayList<Email>();
        String query;
        Email e;
        Statement st;
        ResultSet rs;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión esta cerrada");
                return new ArrayList<Email>();
            }

            query = "SELECT * FROM \"PIO\".email";
            System.out.println(query);

            st = conexion.createStatement();

            rs = st.executeQuery(query);

            if (rs.next()) {
                e = new Email();
                e.setCorreoRemitente(rs.getString("correoRemitente"));
                e.setClave(rs.getString("clave"));

                result.add(e);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList<Email>();
        }
        return result;
    }

    /**
     * Modifica el email de la base de datos utilizando el correoRemitente y la
     * clave del parámetro de entrada
     *
     * @param p Email que indica los datos a modificar
     * @return true si la modificacion tuvo exito, false en caso contrario
     */
    public boolean modificarEmail(Email p) {
        String query;
        int mod;
        Statement st;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return false;
            }

            query = "UPDATE \"PIO\".email";

            if ((null != p.getCorreoRemitente()) && !p.getCorreoRemitente().isEmpty()) {
                if (isFirst) {
                    query += " SET correoRemitente = '" + p.getCorreoRemitente() + "'";
                    isFirst = false;
                } else {
                    query += ", correoRemitente = '" + p.getCorreoRemitente() + "'";
                }
            }

            if ((null != p.getClave()) && !p.getClave().isEmpty()) {
                if (isFirst) {
                    query += " SET clave = '" + p.getClave() + "'";
                    isFirst = false;
                } else {
                    query += ", clave = '" + p.getClave() + "'";
                }
            }

            System.out.println(query);
            st = conexion.createStatement();
            mod = st.executeUpdate(query);

        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return mod > 0;
    }

    /**
     * Agrega a la base de datos el preinscrito indicado por el parámetro. El
     * método asume que ya existe un aspirante con igual cédula presente en la
     * base de datos
     *
     * @param p Objeto que contiene la información a agregar
     * @return true si se agregó con éxtio, false en caso contrario
     */
    public boolean agregarPreinscrito(Preinscrito p) {
        String query;
        Statement st;
        int agregados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            query = "INSERT INTO \"PIO\".preinscrito(cedula"
                    + (p.getTurnoPrueba() != null ? ",turnoprueba" : "")
                    + (p.getAulaPrueba() != null ? ",aulaprueba" : "")
                    + (p.getNotaTest() != null ? ",notatest" : "")
                    + (p.getNotaPio() != null ? ",notapio" : "")
                    + (p.getNotaRaven() != null ? ",notaraven" : "")
                    + (p.getSede() != null ? ",sede" : "")
                    + (p.getIdInscripcion() != null ? ",id_inscrip" : "")
                    + " ) VALUES ("
                    + "'" + p.getCedula() + "'"
                    + (p.getTurnoPrueba() != null ? ",'" + p.getTurnoPrueba() + "'" : "")
                    + (p.getAulaPrueba() != null ? ",'" + p.getAulaPrueba() + "'" : "")
                    + (p.getNotaTest() != null ? ",'" + p.getNotaTest() + "'" : "")
                    + (p.getNotaPio() != null ? ",'" + p.getNotaPio() + "'" : "")
                    + (p.getNotaRaven() != null ? ",'" + p.getNotaRaven() + "'" : "")
                    + (p.getSede() != null ? ",'" + p.getSede() + "'" : "")
                    + (p.getIdInscripcion() != null && p.getIdInscripcion() != 0 ? "," + p.getIdInscripcion() : "")
                    + ")";

            System.out.println(query);
            st = conexion.createStatement();
            agregados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return agregados > 0;
    }

    /**
     * Método que consulta en la base de datos todos los preinscritos que
     * concuerden con los atributos del parámetro. Se asume que los aqtributos
     * que se pasan en null, string vacío o -1 no son tomados en cuenta
     *
     * @param p Objeto que contiene el query a realizar
     * @return
     */
    public ArrayList<Preinscrito> consultarPreinscritos(Preinscrito p) {
        String query;
        String queryAux;
        Statement st;
        ResultSet rs;
        Preinscrito paux;
        boolean isFirst = true;
        ArrayList<Preinscrito> res = new ArrayList<Preinscrito>();
        ArrayList<InstitucionAspirante> ias = consultarAspirantes(p);
        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return new ArrayList<Preinscrito>();
            }

            query = "SELECT * FROM \"PIO\".preinscrito";

            if (null != p.getId()) {
                if (isFirst) {
                    query += " WHERE id = " + p.getId();
                    isFirst = false;
                } else {
                    query += " AND id = " + p.getId();
                }
            }
            if (null != p.getTurnoPrueba()) {
                if (isFirst) {
                    query += " WHERE turnoprueba = " + p.getTurnoPrueba();
                    isFirst = false;
                } else {
                    query += " AND turnoprueba = " + p.getTurnoPrueba();
                }
            }

            if (null != p.getAulaPrueba()) {
                if (isFirst) {
                    query += " WHERE aulaprueba = '" + p.getAulaPrueba() + "'";
                    isFirst = false;
                } else {
                    query += " AND aulaprueba = '" + p.getAulaPrueba() + "'";
                }
            }

            if (null != p.getNotaTest()) {
                if (isFirst) {
                    query += " WHERE notatest = " + p.getNotaTest();
                    isFirst = false;
                } else {
                    query += " AND notatest = " + p.getNotaTest();
                }
            }

            if (null != p.getNotaPio()) {
                if (isFirst) {
                    query += " WHERE notapio = " + p.getNotaPio();
                    isFirst = false;
                } else {
                    query += " AND notapio = " + p.getNotaPio();
                }
            }

            if (null != p.getNotaRaven()) {
                if (isFirst) {
                    query += " WHERE notaraven = " + p.getNotaRaven();
                    isFirst = false;
                } else {
                    query += " AND notaraven = " + p.getNotaRaven();
                }
            }

            if (null != p.getSede()) {
                if (isFirst) {
                    query += " WHERE sede = '" + p.getSede() + "'";
                    isFirst = false;
                } else {
                    query += " AND sede = '" + p.getSede() + "'";
                }
            }

            if (null != p.getIdInscripcion() && p.getIdInscripcion() != 0) {
                if (isFirst) {
                    query += " WHERE id_inscrip = " + p.getIdInscripcion();
                    isFirst = false;
                } else {
                    query += " AND id_inscrip = " + p.getIdInscripcion();
                }
            }

            for (InstitucionAspirante ia : ias) {
                for (Aspirante asp : ia.getAspirantes()) {
                    if (isFirst) {
                        queryAux = query + " WHERE cedula = '" + asp.getCedula() + "'";
                    } else {
                        queryAux = query + " AND cedula = '" + asp.getCedula() + "'";
                    }

                    System.out.println(queryAux);
                    st = conexion.createStatement();
                    rs = st.executeQuery(queryAux);

                    if (rs.next()) {
                        paux = new Preinscrito();
                        paux.cloneWith(asp);
                        paux.setTurnoPrueba(rs.getInt("turnoprueba"));
                        paux.setAulaPrueba(rs.getString("aulaprueba"));
                        paux.setNotaTest(rs.getInt("notatest"));
                        paux.setNotaRaven(rs.getInt("notaraven"));
                        paux.setNotaPio(rs.getInt("notapio"));
                        paux.setSede(rs.getString("sede"));
                        paux.setId(rs.getInt("id"));
                        paux.setIdInscripcion(rs.getInt("id_inscrip"));
                        res.add(paux);
                    }
                }
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList<Preinscrito>();
        }

        return res;
    }

    /**
     * Elimina de la base de datos al preinscrito que posea la misma cédula que
     * el especificado, a demás elimina su usuario
     *
     * @param p Objeto que contiene la información del preinscrito a eliminar
     * @return true si tuvo éxito, false en caso contrario
     */
    public boolean eliminarPreinscrito(Preinscrito p) {
        String query;
        Statement st;
        int eliminados;
        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            query = "DELETE FROM \"PIO\".usuario WHERE cedula = '" + p.getCedula()
                    + "'";

            System.out.println(query);
            st = conexion.createStatement();
            eliminados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return eliminados > 0;
    }

    /**
     * Elimina a todos los preinscritos de la base de datos y reinicia la
     * secuencia de identificadores
     *
     * @return true si el método tuvo éxito, false en caso contrario
     */
    public boolean eliminarPreinscritos() {
        int eliminados = 0;
        String query;
        Statement st;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexió está cerrada");
                return false;
            }

            query = "ALTER SEQUENCE \"PIO\".preinscrito_id RESTART";
            System.out.println(query);

            st = conexion.createStatement();
            st.executeUpdate(query);

            query = "DELETE FROM \"PIO\".preinscrito";
            System.out.println(query);
            eliminados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return eliminados >= 0;
    }

    /**
     * Sustituye los datos del preinscrito en la base de datos que posea la
     * misma cédula que el parámatro, por los atributos del parámetro que sean
     * distintos de null
     *
     * @param p
     * @return
     */
    public boolean modificarPreinscrito(Preinscrito p) {
        String query;
        Statement st;
        int modificados;
        boolean isFirst = true;
        this.modificarAspirante((Aspirante) p);
        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            query = "UPDATE \"PIO\".preinscrito";

            if (null != p.getTurnoPrueba()) {
                if (isFirst) {
                    query += " SET turnoprueba = " + p.getTurnoPrueba();
                    isFirst = false;
                } else {
                    query += ", turnoprueba = " + p.getTurnoPrueba();
                }
            }

            if (null != p.getAulaPrueba()) {
                if (isFirst) {
                    query += " SET aulaprueba = '" + p.getAulaPrueba() + "'";
                    isFirst = false;
                } else {
                    query += ", aulaprueba = '" + p.getAulaPrueba() + "'";
                }
            }

            if (null != p.getNotaTest()) {
                if (isFirst) {
                    query += " SET notatest = " + p.getNotaTest();
                    isFirst = false;
                } else {
                    query += ", notatest = " + p.getNotaTest();
                }
            }

            if (null != p.getNotaPio()) {
                if (isFirst) {
                    query += " SET notapio = " + p.getNotaPio();
                    isFirst = false;
                } else {
                    query += ", notapio = " + p.getNotaPio();
                }
            }

            if (null != p.getNotaRaven()) {
                if (isFirst) {
                    query += " SET notaraven = " + p.getNotaRaven();
                    isFirst = false;
                } else {
                    query += ", notaraven = " + p.getNotaRaven();
                }
            }

            if (null != p.getSede()) {
                if (isFirst) {
                    query += " SET sede = '" + p.getSede() + "'";
                    isFirst = false;
                } else {
                    query += ", sede = '" + p.getSede() + "'";
                }
            }

            if (null != p.getIdInscripcion() && p.getIdInscripcion() != 0) {
                if (isFirst) {
                    query += " SET id_inscrip = " + p.getIdInscripcion();
                    isFirst = false;
                } else {
                    query += ", id_inscrip = " + p.getIdInscripcion();
                }
            }
            query += " WHERE cedula = '" + p.getCedula() + "'";

            System.out.println(query);
            st = conexion.createStatement();
            modificados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return modificados > 0;
    }

    /**
     * Método que devuelve los criterios que se deben utilizar para corregir un
     * test
     *
     * @param criterioTest Entrada 'dummy' ya que la tabla correspondiente solo
     * contara con una entrada
     * @return ArrayList con el elemento que contiene la informacion de los
     * criterios de correccion
     */
    public ArrayList<CriterioTest> consultarCriterioTest(CriterioTest criterioTest) {
        String query;
        ArrayList<CriterioTest> res = new ArrayList<CriterioTest>();
        Statement st;
        ResultSet rs;
        CriterioTest ct;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return new ArrayList<CriterioTest>();
            }

            query = "SELECT * FROM \"PIO\".criteriostest";
            System.out.println(query);

            st = conexion.createStatement();
            rs = st.executeQuery(query);

            while (rs.next()) {
                ct = new CriterioTest();
                ct.setMaxPreinscrito(rs.getInt("maxpreinscrito"));
                ct.setMinPorcentaje(rs.getInt("minporcentaje"));

                res.add(ct);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList<CriterioTest>();
        }

        return res;
    }

    /**
     * Modifica la entrada en la base de datos que contiene los criterios de
     * correccion del test vocacional.
     *
     * @param criterio Objeto que contiene los criterios a modificar. Los
     * criterios en -2 se considera que no se desean modificar
     * @return
     */
    public boolean modificarCriterioTest(CriterioTest c) {
        String query;
        Statement st;
        int mod;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return false;
            }

            query = "UPDATE \"PIO\".criteriostest";

            if (c.getMaxPreinscrito() != -2) {
                if (isFirst) {
                    query += " SET maxpreinscrito = " + c.getMaxPreinscrito();
                    isFirst = false;
                } else {
                    query += ", maxpreinscrito = " + c.getMaxPreinscrito();
                }
            }

            if (c.getMinPorcentaje() != -2) {
                if (isFirst) {
                    query += " SET minporcentaje = " + c.getMinPorcentaje();
                    isFirst = false;
                } else {
                    query += ", minporcentaje = " + c.getMinPorcentaje();
                }
            }

            System.out.println(query);
            st = conexion.createStatement();

            mod = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return mod > 0;
    }

    // retorna una lista de vocacional la cual sean respuesta a opciones correcta,
    // puede ser una tupla por usuario y pregunta
    // es decir si tengo 10 pregunta y hay una pregunta q tiene 10 opciones buena
    // si el aspirante respondio las 10 correcta, basta con devolver 1 tupla
    // la lista debe estar ordenada por cedula, luego por pregunta, luego por opcion.
    public ArrayList<Vocacional> consultarVocacionalCorrecto() {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    /**
     * Método que agrega la parada especificada como parámetro a la base de
     * datos
     *
     * @param p Objeto con la información de la parada a agregar
     * @return true si se agregó correctamente, false en caso contrario
     */
    public boolean agregarParada(Parada p) {
        String query;
        Statement st;
        int agregados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            query = "INSERT INTO \"PIO\".parada(nombre, descripcion) VALUES ("
                    + "'" + (p.getNombre() == null ? "" : p.getNombre()) + "'"
                    + ",'" + (p.getDescripcion() == null ? "" : p.getDescripcion()) + "'"
                    + ")";

            System.out.println(query);
            st = conexion.createStatement();
            agregados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return agregados > 0;
    }

    //Este método es exactamente igual a hacer una llamada a consultarParada
    //pasando como parámetro un elemento sin valores para consultar
    public ArrayList consultarParadas() {
        ArrayList a = new ArrayList();
        Parada p = new Parada();
        p.setId(1);
        p.setNombre("Bellas Artes");
        a.add(p);
        return a;
    }

    /**
     * Realiza una consulta sobre la tabla "PIO".parada, usando como parámetros
     * para la consulta los valores contenidos en el parámetro
     *
     * @param p Objeto con los valores que se desea consultar. Se asume que los
     * valores en null o vacio no se desean consultar
     * @return ArrayList con objetos que representan los resultados de la
     * consulta
     */
    public ArrayList<Parada> consultarParada(Parada p) {
        ArrayList<Parada> res = new ArrayList<Parada>();
        String query;
        Statement st;
        ResultSet rs;
        boolean isFirst = true;
        Parada paux;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return new ArrayList<Parada>();
            }
            query = "SELECT * FROM \"PIO\".parada";

            if (null != p.getId()) {
                if (isFirst) {
                    query += " WHERE id = " + p.getId();
                    isFirst = false;
                } else {
                    query += " AND id = " + p.getId();
                }
            }

            if ((null != p.getNombre()) && !p.getNombre().isEmpty()) {
                if (isFirst) {
                    query += " WHERE nombre = '" + p.getNombre() + "'";
                    isFirst = false;
                } else {
                    query += " AND nombre = '" + p.getNombre() + "'";
                }
            }

            if ((null != p.getDescripcion()) && !p.getDescripcion().isEmpty()) {
                if (isFirst) {
                    query += " WHERE descripcion = '" + p.getDescripcion() + "'";
                    isFirst = false;
                } else {
                    query += " AND descripcion = '" + p.getDescripcion() + "'";
                }
            }

            System.out.println(query);
            st = conexion.createStatement();
            rs = st.executeQuery(query);

            while (rs.next()) {
                paux = new Parada();
                paux.setId(rs.getInt("id"));
                paux.setNombre(rs.getString("nombre"));
                paux.setDescripcion(rs.getString("descripcion"));

                res.add(paux);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList<Parada>();
        }
        return res;
    }

    /**
     * Modifica la entrada en la tabla "PIO".parada con igual id que el
     * parámetro dado, modificando los atributos de la entrada que no se
     * encuentren en null o vacío
     *
     * @param p Objeto con la información de la entrada a modificar
     * @return true si la operación tuvo éxito, false en caso contrario
     */
    public boolean modificarParada(Parada p) {
        String query;
        Statement st;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            query = "UPDATE \"PIO\".parada";

            if ((null != p.getNombre()) && !p.getNombre().isEmpty()) {
                if (isFirst) {
                    query += " SET nombre = '" + p.getNombre() + "'";
                    isFirst = false;
                } else {
                    query += ", nombre = '" + p.getNombre() + "'";
                }
            }

            if ((null != p.getDescripcion()) && !p.getDescripcion().isEmpty()) {
                if (isFirst) {
                    query += " SET descripcion = '" + p.getDescripcion() + "'";
                    isFirst = false;
                } else {
                    query += ", descripcion = '" + p.getDescripcion() + "'";
                }
            }

            query += " WHERE id = " + p.getId();
            System.out.println(query);
            st = conexion.createStatement();
            st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return true;
    }

    /**
     * Elimina de la base de datos la parada con el mismo id del parámetro
     *
     * @param p Objeto con la información de la parada a eliminar
     * @return true si el proceso tuvo éxto, false en caso contrario
     */
    public boolean eliminarParada(Parada p) {
        int eliminados;
        String query;
        Statement st;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            query = "DELETE FROM \"PIO\".parada WHERE id = " + p.getId();
            System.out.println(query);
            st = conexion.createStatement();
            eliminados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return eliminados > 0;
    }

    /**
     * Dado un turno devuelve todas las paradas que están asociadas a ese turno
     *
     * @param t Objeto que contiene el identificador del turno a consultar
     * @return Arreglo
     */
    public ArrayList<Parada> obtenerParadasDeTurno(Turno t) {
        String query;
        Statement st;
        boolean estaParada[];
        boolean consultadaInstitucion[];
        ArrayList<Parada> res = new ArrayList<Parada>();;
        ResultSet rsCountParada, rsCountIns, rsParAlt, rsIns;
        Parada paux;

        try {
            if (conexion.isClosed()) {
                System.err.println("La conexión está cerrada");
                return new ArrayList<Parada>();
            }

            //Se obtiene el id más alto entre las paradas para inicializar el arreglo
            //estaParada
            query = "SELECT * FROM \"PIO\".parada WHERE id = (SELECT max(id) FROM "
                    + "\"PIO\".parada)";
            st = conexion.createStatement();
            System.out.println(query);
            rsCountParada = st.executeQuery(query);
            if (rsCountParada.next()) {
                estaParada = new boolean[rsCountParada.getInt("id") + 1];
            } else {
                System.out.println("Error contando el número de paradas");
                return new ArrayList<Parada>();
            }

            //Se obtiene el id más alto entre las instituciones para inicializar el
            //arreglo consultadaInstitucion
            query = "SELECT * FROM \"PIO\".institucion WHERE id = (SELECT max(id) FROM "
                    + "\"PIO\".institucion)";

            System.out.println(query);
            rsCountIns = st.executeQuery(query);
            if (rsCountIns.next()) {
                consultadaInstitucion = new boolean[rsCountIns.getInt("id") + 1];
            } else {
                System.out.println("Error contando el número de instituciones");
                return new ArrayList<Parada>();
            }

            //Primero se obtienen todas las paradas asociadas al turno que sean 
            //alternas
            query = "SELECT * FROM \"PIO\".parada_alterna pa JOIN \"PIO\".parada p"
                    + " ON pa.idparada = p.id"
                    + " WHERE pa.idturno = " + t.getId();

            System.out.println(query);
            rsParAlt = st.executeQuery(query);
            while (rsParAlt.next()) {
                if (!estaParada[rsParAlt.getInt("id")]) {
                    paux = new Parada();
                    paux.setId(rsParAlt.getInt("id"));
                    paux.setNombre(rsParAlt.getString("nombre"));
                    paux.setDescripcion(rsParAlt.getString("descripcion"));

                    res.add(paux);
                    estaParada[rsParAlt.getInt("id")] = true;
                }
                consultadaInstitucion[rsParAlt.getInt("idinstitucion")] = true;
            }

            //Ahora se obtienen, de las instituciones que no se obtuvieron
            //paradas alternas, sus paradas originales
            query = "SELECT * FROM \"PIO\".institucion i JOIN \"PIO\".parada p\n"
                    + " ON i.idparada = p.id\n"
                    + " WHERE EXISTS(SELECt * FROM \"PIO\".preinscrito pr\n"
                    + "             WHERE EXISTS(SELECT * FROM \"PIO\".aspirante a\n"
                    + "                           WHERE a.cedula = pr.cedula \n"
                    + "                                 AND a.institucionid = i.id)\n"
                    + "             AND\n"
                    + "             pr.turnoprueba = " + t.getId() + ")";

            System.out.println(query);
            rsIns = st.executeQuery(query);
            while (rsIns.next()) {
                if (!consultadaInstitucion[rsIns.getInt(1)]) {
                    if (!estaParada[rsIns.getInt(4)]) {
                        paux = new Parada();
                        paux.setId(rsIns.getInt(4));
                        paux.setNombre(rsIns.getString(5));
                        paux.setDescripcion(rsIns.getString(6));

                        res.add(paux);
                        estaParada[rsIns.getInt(4)] = true;
                    }
                }
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList<Parada>();
        }
        return res;
    }

    /**
     * Método que, dado un turno, devuelve una lista de enteros en la que el
     * elemento 'i' representa el número de preinscritos que irán en el turno
     * indicado a la parada 'i' de la lista retornada por obtenerParadasDeTurno
     *
     * @param t Objeto con la información del turno a consultar
     * @return Lista con el conteo deseado o una lista vacía si hubo error
     */
    public ArrayList<Integer> obtenerNumeroPreinscritosDeTurno(Turno t) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        ArrayList<Parada> ps;
        Integer numEst;
        String query;
        Statement st;
        ResultSet rsNumPre;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return new ArrayList<Integer>();
            }

            ps = this.obtenerParadasDeTurno(t);

            for (Parada p : ps) {
                numEst = new Integer(0);

                //Primero se agregan los preinscritos de las instituciones que 
                //concuerden con paradas alternas
                query = "SELECT COUNT(*) FROM \"PIO\".preinscrito pr WHERE\n"
                        + " pr.turnoprueba = " + t.getId() + "\n"
                        + " AND\n"
                        + " EXISTS(\n"
                        + "  SELECT * FROM \"PIO\".aspirante a JOIN \"PIO\".parada_alterna p\n"
                        + "    ON a.institucionid = p.idinstitucion \n"
                        + "    WHERE a.cedula = pr.cedula \n"
                        + "      AND p.idparada = " + p.getId() + "\n"
                        + "      AND p.idturno = " + t.getId() + ")";

                System.out.println(query);
                st = conexion.createStatement();
                rsNumPre = st.executeQuery(query);

                if (rsNumPre.next()) {
                    numEst += rsNumPre.getInt("count");
                } else {
                    System.out.println("Error calculando el número de preinscritos que "
                            + "tienen como parada alterna: " + p.getNombre());
                    return new ArrayList<Integer>();
                }

                rsNumPre.close();

                //Luego se agregan los preinscritos de las instituciones que no tienen
                //paradas alternas
                query = "SELECT COUNT(*) FROM \"PIO\".preinscrito pr WHERE\n"
                        + " pr.turnoprueba = " + t.getId() + "\n"
                        + " AND\n"
                        + " EXISTS (SELECT * FROM \"PIO\".aspirante a JOIN \n"
                        + "         \"PIO\".institucion i ON a.institucionid = i.id \n"
                        + "         WHERE i.idparada = " + p.getId() + "\n"
                        + "           AND a.cedula = pr.cedula\n"
                        + "         )\n"
                        + " AND\n"
                        + " NOT EXISTS (SELECT * FROM \"PIO\".aspirante a JOIN \"PIO\".parada_alterna p\n"
                        + "    ON a.institucionid = p.idinstitucion \n"
                        + "    WHERE a.cedula = pr.cedula \n"
                        + "      AND p.idturno = " + t.getId() + ")";

                System.out.println(query);
                rsNumPre = st.executeQuery(query);

                if (rsNumPre.next()) {
                    numEst += rsNumPre.getInt("count");
                } else {
                    System.out.println("Error calculando el número de preinscritos que "
                            + "tienen como parada alterna: " + p.getNombre());
                    return new ArrayList<Integer>();
                }

                rsNumPre.close();

                res.add(numEst);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList<Integer>();
        }
        return res;
    }

    /**
     * Agrega a la base de datos el turno indicado
     *
     * @param t Objeto con la información a agregar en la base de datos
     * @return true si la operación tuvo éxito, false en caso contrario
     */
    public boolean agregarTurno(Turno t) {
        int agregados;
        String query;
        Statement st;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexion esta cerrada");
                return false;
            }

            query = "INSERT INTO \"PIO\".turno (capacidad, hora, dia, sede) VALUES ("
                    + t.getCapacidad()
                    + ", '" + t.getHora() + "'"
                    + ", '" + t.getDia() + "'"
                    + ", '" + t.getSede() + "'"
                    + ")";

            System.out.println(query);
            st = conexion.createStatement();
            agregados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return agregados > 0;
    }

    /**
     * Retorna el conunto de turnos que concuerdan con la consulta indicada por
     * la entrada
     *
     * @param t Objeto que contiene los elementos por los que se consultará. Se
     * considera que no se desea consultar los objetos que vienen en null o
     * vacío
     * @return ArrayList con objetos Turno que concuerdan con la consulta
     */
    public ArrayList<Turno> consultarTurno(Turno t) {
        String query;
        ResultSet rs;
        Statement st;
        Turno taux;
        boolean isFirst = true;
        ArrayList<Turno> res = new ArrayList<Turno>();

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return res;
            }

            query = "SELECT * FROM \"PIO\".turno";

            if (null != t.getId()) {
                if (isFirst) {
                    query += " WHERE id = " + t.getId();
                    isFirst = false;
                } else {
                    query += " AND id = " + t.getId();
                }
            }

            if (null != t.getCapacidad()) {
                if (isFirst) {
                    query += " WHERE capacidad = " + t.getCapacidad();
                    isFirst = false;
                } else {
                    query += " AND capacidad = " + t.getCapacidad();
                }
            }

            if ((null != t.getHora()) && !t.getHora().isEmpty()) {
                if (isFirst) {
                    query += " WHERE hora = '" + t.getHora() + "'";
                    isFirst = false;
                } else {
                    query += " AND hora = '" + t.getHora() + "'";
                }
            }

            if ((null != t.getDia()) && !t.getDia().isEmpty()) {
                if (isFirst) {
                    query += " WHERE dia = '" + t.getDia() + "'";
                    isFirst = false;
                } else {
                    query += " AND dia = '" + t.getDia() + "'";
                }
            }

            System.out.println(query);
            st = conexion.createStatement();
            rs = st.executeQuery(query);

            while (rs.next()) {
                taux = new Turno();
                taux.setId(rs.getInt("id"));
                taux.setCapacidad(rs.getInt("capacidad"));
                taux.setDia(rs.getString("dia"));
                taux.setHora(rs.getString("hora"));
                taux.setSede(rs.getString("sede"));

                res.add(taux);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList<Turno>();
        }
        return res;
    }

    /**
     * Cambia en la base de datos los valores del turno con igual id a la
     * entrada por los valores que sean especificados no nulos en la entrada
     *
     * @param t Objeto que contiene la consulta a realizar
     * @return true si la modificacion fue exitosa, false en caso contrario
     */
    public boolean modificarTurno(Turno t) {
        String query;
        Statement st;
        int modificados;
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            query = "UPDATE \"PIO\".turno";

            if (null != t.getCapacidad()) {
                if (isFirst) {
                    query += " SET capacidad = " + t.getCapacidad();
                    isFirst = false;
                } else {
                    query += ", capacidad = " + t.getCapacidad();
                }
            }

            if ((null != t.getDia()) && !t.getDia().isEmpty()) {
                if (isFirst) {
                    query += " SET dia = '" + t.getDia() + "'";
                    isFirst = false;
                } else {
                    query += ", dia = '" + t.getDia() + "'";
                }
            }

            if ((null != t.getHora()) && !t.getHora().isEmpty()) {
                if (isFirst) {
                    query += " SET hora = '" + t.getHora() + "'";
                    isFirst = false;
                } else {
                    query += ", hora = '" + t.getHora() + "'";
                }
            }

            if (null != t.getSede()) {
                if (isFirst) {
                    query += " SET sede = '" + t.getSede() + "'";
                    isFirst = false;
                } else {
                    query += ", sede = '" + t.getSede() + "'";
                }
            }

            query += " WHERE id = " + t.getId();

            System.out.println(query);
            st = conexion.createStatement();
            modificados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }

        return modificados > 0;
    }

    /**
     * Elimina de la base de datos el turno con igual id al parámetro
     *
     * @param t Objeto con la información del turno a eliminar
     * @return true si se eliminó con éxito, false en caso contrario
     */
    public boolean eliminarTurno(Turno t) {
        String query;
        Statement st;
        int eliminados;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            query = "DELETE FROM \"PIO\".turno WHERE id = " + t.getId();

            System.out.println(query);
            st = conexion.createStatement();
            eliminados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }

        return eliminados > 0;
    }

    /**
     * Método que agrega la instancia de ResultadoPrueba especificada a la base
     * de datos
     *
     * @param a Objeto con la información del elemento a agregar
     * @return true si la operación tiene éxito, false en caso contrario
     */
    public boolean agregarResultadoPrueba(ResultadoPrueba a) {
        String query;
        Statement st;
        int ag;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            query = "INSERT INTO \"PIO\".resultado_prueba (cedula"
                    + (a.getNombrePrueba() != null ? ",nombre_prueba" : "")
                    + (a.getNumTotPreg() != null ? ",num_total_preg" : "")
                    + (a.getNotaTotal() != null ? ",nota_total" : "")
                    + ") VALUES ("
                    + "'" + a.getCedula() + "'"
                    + (a.getNombrePrueba() != null ? ",'" + a.getNombrePrueba() + "'" : "")
                    + (a.getNumTotPreg() != null ? "," + a.getNumTotPreg() : "")
                    + (a.getNotaTotal() != null ? "," + a.getNotaTotal() : "")
                    + ")";

            System.out.println(query);
            st = conexion.createStatement();
            ag = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return ag > 0;
    }

    /**
     * Sustituye los datos de resultadoPrueba en la base de datos que posea la
     * misma id que el parámatro, por los atributos del parámetro que sean
     * distintos de null
     *
     * @param p
     * @return
     */
    public boolean modificarResultadoPrueba(ResultadoPrueba p) {
        String query;
        Statement st;
        int modificados;
        boolean isFirst = true;
        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            query = "UPDATE \"PIO\".resultado_prueba";

            if (null != p.getCedula()) {
                if (isFirst) {
                    query += " SET cedula = " + p.getCedula();
                    isFirst = false;
                } else {
                    query += ", cedula = " + p.getCedula();
                }
            }
            if (null != p.getNombrePrueba()) {
                if (isFirst) {
                    query += " SET nombre_prueba = '" + p.getNombrePrueba() + "'";
                    isFirst = false;
                } else {
                    query += ", nombre_prueba = '" + p.getNombrePrueba() + "'";
                }
            }
            if (null != p.getNotaTotal()) {
                if (isFirst) {
                    query += " SET nota_total = " + p.getNotaTotal();
                    isFirst = false;
                } else {
                    query += ", nota_total = " + p.getNotaTotal();
                }
            }

            if (null != p.getNumTotPreg()) {
                if (isFirst) {
                    query += " SET num_total_preg = " + p.getNumTotPreg();
                    isFirst = false;
                } else {
                    query += ", num_total_preg = " + p.getNumTotPreg();
                }
            }

            query += " WHERE id = '" + p.getId() + "'";

            System.out.println(query);
            st = conexion.createStatement();
            modificados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return modificados > 0;
    }

    /**
     * Método para consultar los diferentes resultados de pruebas de los alumnos
     * basándose en el objeto de consulta pasado. Los atributos que sean pasados
     * en null no serán tomados en cuenta para la consulta
     *
     * @param a Objeto con la consulta a realizar
     * @return ArrayList con todos los objetos de la base de datos que
     * concuerden con la consulta
     */
    public ArrayList<ResultadoPrueba> consultarResultadoPrueba(ResultadoPrueba a) {
        ArrayList<ResultadoPrueba> res = new ArrayList<ResultadoPrueba>();
        Statement st;
        String query;
        ResultadoPrueba aux;
        boolean isFirst = true;
        ResultSet rs;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return new ArrayList<ResultadoPrueba>();
            }

            query = "SELECT * FROM \"PIO\".resultado_prueba";

            if (null != a.getCedula()) {
                if (isFirst) {
                    query += " WHERE cedula = '" + a.getCedula() + "'";
                    isFirst = false;
                } else {
                    query += " AND cedula = '" + a.getCedula() + "'";
                }
            }

            if (null != a.getId()) {
                if (isFirst) {
                    query += " WHERE id = " + a.getId();
                    isFirst = false;
                } else {
                    query += " AND id = " + a.getId();
                }
            }

            if (null != a.getNombrePrueba()) {
                if (isFirst) {
                    query += " WHERE nombre_prueba = '" + a.getNombrePrueba() + "'";
                    isFirst = false;
                } else {
                    query += " AND nombre_prueba = '" + a.getNombrePrueba() + "'";
                }
            }

            if (null != a.getNumTotPreg()) {
                if (isFirst) {
                    query += " WHERE num_total_preg = " + a.getNumTotPreg();
                    isFirst = false;
                } else {
                    query += " AND num_total_preg = " + a.getNumTotPreg();
                }
            }

            if (null != a.getNotaTotal()) {
                if (isFirst) {
                    query += " WHERE nota_total = " + a.getNotaTotal();
                    isFirst = false;
                } else {
                    query += " AND nota_total = " + a.getNotaTotal();
                }
            }

            System.out.println(query);
            st = conexion.createStatement();
            rs = st.executeQuery(query);

            while (rs.next()) {
                aux = new ResultadoPrueba();
                aux.setCedula(rs.getString("cedula"));
                aux.setId(rs.getInt("id"));
                aux.setNombrePrueba(rs.getString("nombre_prueba"));
                aux.setNumTotPreg(rs.getInt("num_total_preg"));
                aux.setNotaTotal(rs.getInt("nota_total"));

                res.add(aux);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList<ResultadoPrueba>();
        }
        return res;
    }

    /**
     * Método para agregar el objeto pasado como parámetro a la base de datos
     *
     * @param a Objeto con la información del elemento a agregar
     * @return true si la operación tuvo éxito, false en caso contrario
     */
    public boolean agregarResultadoSeccionPrueba(ResultadoSeccionPrueba a) {
        Statement st;
        String query;
        int ag;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            query = "INSERT INTO \"PIO\".resultado_seccion_prueba(id_prueba, nombre_seccion"
                    + (a.getNumPregs() != null ? ",num_preg" : "")
                    + (a.getPonderacion() != null ? ",ponderacion" : "")
                    + (a.getNotaParcial() != null ? ",nota_parcial" : "")
                    + ") VALUES ("
                    + a.getIdPrueba()
                    + ",'" + a.getNombreSeccion() + "'"
                    + (a.getNumPregs() != null ? "," + a.getNumPregs() : "")
                    + (a.getPonderacion() != null ? "," + a.getPonderacion() : "")
                    + (a.getNotaParcial() != null ? "," + a.getNotaParcial() : "")
                    + ")";

            System.out.println(query);
            st = conexion.createStatement();
            ag = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return ag > 0;
    }

    public boolean modificarResultadoSeccionPrueba(ResultadoSeccionPrueba p) {
        String query;
        Statement st;
        int modificados;
        boolean isFirst = true;
        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }
            query = "UPDATE \"PIO\".resultado_seccion_prueba";

            if (null != p.getNotaParcial()) {
                if (isFirst) {
                    query += " SET nota_parcial = " + p.getNotaParcial();
                    isFirst = false;
                } else {
                    query += ", nota_parcial = " + p.getNotaParcial();
                }
            }

            if (null != p.getNumPregs()) {
                if (isFirst) {
                    query += " SET num_preg = " + p.getNumPregs();
                    isFirst = false;
                } else {
                    query += ", num_preg = " + p.getNumPregs();
                }
            }

            if (null != p.getPonderacion()) {
                if (isFirst) {
                    query += " SET ponderacion = " + p.getPonderacion();
                    isFirst = false;
                } else {
                    query += ", ponderacion = " + p.getPonderacion();
                }
            }

            query += " WHERE id_prueba = '" + p.getIdPrueba() + "' AND "
                    + "nombre_seccion = '" + p.getNombreSeccion() + "'";

            System.out.println(query);
            st = conexion.createStatement();
            modificados = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return modificados > 0;
    }

    /**
     * Método que consulta en la base de datos los resultados por secciones de
     * una prueba, basándose en el parámetro dado. Se asume que los atributos
     * del parámetro pasados en null son aquellos por los que no se quiere
     * consultar
     *
     * @param a Objeto que contiene la consulta a realizar
     * @return ArrayList con todos los elementos de la base de datos que
     * concuerdan con la búsqueda
     */
    public ArrayList<ResultadoSeccionPrueba> consultarResultadoSeccionPrueba(ResultadoSeccionPrueba a) {
        Statement st;
        ResultSet rs;
        String query;
        ResultadoSeccionPrueba aux;
        ArrayList<ResultadoSeccionPrueba> res = new ArrayList<ResultadoSeccionPrueba>();
        boolean isFirst = true;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return new ArrayList<ResultadoSeccionPrueba>();
            }

            query = "SELECT * FROM \"PIO\".resultado_seccion_prueba";

            if (null != a.getIdPrueba()) {
                if (isFirst) {
                    query += " WHERE id_prueba = " + a.getIdPrueba();
                    isFirst = false;
                } else {
                    query += " AND id_prueba = " + a.getIdPrueba();
                }
            }

            if (null != a.getNombreSeccion()) {
                if (isFirst) {
                    query += " WHERE nombre_seccion = '" + a.getNombreSeccion() + "'";
                    isFirst = false;
                } else {
                    query += " AND nombre_seccion = '" + a.getNombreSeccion() + "'";
                }
            }

            if (null != a.getNumPregs()) {
                if (isFirst) {
                    query += " WHERE num_preg = " + a.getNumPregs();
                    isFirst = false;
                } else {
                    query += " AND num_preg = " + a.getNumPregs();
                }
            }

            if (null != a.getPonderacion()) {
                if (isFirst) {
                    query += " WHERE ponderacion = " + a.getPonderacion();
                    isFirst = false;
                } else {
                    query += " AND ponderacion = " + a.getPonderacion();
                }
            }

            if (null != a.getNotaParcial()) {
                if (isFirst) {
                    query += " WHERE nota_parcial = " + a.getNotaParcial();
                    isFirst = false;
                } else {
                    query += " AND nota_parcial = " + a.getNotaParcial();
                }
            }

            System.out.println(query);
            st = conexion.createStatement();
            rs = st.executeQuery(query);

            while (rs.next()) {
                aux = new ResultadoSeccionPrueba();
                aux.setIdPrueba(rs.getInt("id_prueba"));
                aux.setNombreSeccion(rs.getString("nombre_seccion"));
                aux.setNumPregs(rs.getInt("num_preg"));
                aux.setPonderacion(rs.getInt("ponderacion"));
                aux.setNotaParcial(rs.getInt("nota_parcial"));

                res.add(aux);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList<ResultadoSeccionPrueba>();
        }

        return res;
    }

    /**
     * Método para agregar a la base de datos un período de inscripción
     * especificado por el objeto de entrada
     *
     * @param a Objeto con la información a agregar
     * @return true si la operación tuvo éxito y false en caso contrario
     */
    public boolean agregarPeriodoInscripcion(PeriodoInscripcion a) {
        Statement st;
        String query;
        int ag;

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return false;
            }

            query = "INSERT INTO \"PIO\".periodo_inscripcion(fecha"
                    + (a.getHora() != null ? ",hora" : "")
                    + (a.getSede() != null ? ",sede" : "")
                    + (a.getLugar() != null ? ",lugar" : "")
                    + ") VALUES("
                    + "'" + a.getFecha() + "'"
                    + (a.getHora() != null ? ",'" + a.getHora() + "'" : "")
                    + (a.getSede() != null ? ",'" + a.getSede() + "'" : "")
                    + (a.getLugar() != null ? ",'" + a.getLugar() + "'" : "")
                    + ")";

            System.out.println(query);
            st = conexion.createStatement();
            ag = st.executeUpdate(query);
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return false;
        }
        return ag > 0;
    }

    /**
     * Método para consultar de la base de datos los períodos de inscripción que
     * concuerden con el objeto de la consulta. Se asume que no se desea
     * realizar consulta por los atributos que sean pasados en null
     *
     * @param a Objeto con la información de la consulta
     * @return ArrayList con todos los elementos que concuerdan con la consulta
     * realizada
     */
    public ArrayList<PeriodoInscripcion> consultarPeriodoInscripcion(PeriodoInscripcion a) {
        Statement st;
        String query;
        PeriodoInscripcion aux;
        ResultSet rs;
        boolean isFirst = true;
        ArrayList<PeriodoInscripcion> res = new ArrayList<PeriodoInscripcion>();

        try {
            if (conexion.isClosed()) {
                System.out.println("La conexión está cerrada");
                return new ArrayList<PeriodoInscripcion>();
            }

            query = "SELECT * FROM \"PIO\".periodo_inscripcion";

            if (null != a.getId()) {
                if (isFirst) {
                    query += " WHERE id = " + a.getId();
                    isFirst = false;
                } else {
                    query += " AND id = " + a.getId();
                }
            }

            if (null != a.getFecha()) {
                if (isFirst) {
                    query += " WHERE fecha = '" + a.getFecha() + "'";
                    isFirst = false;
                } else {
                    query += " AND fecha = '" + a.getFecha() + "'";
                }
            }

            if (null != a.getHora()) {
                if (isFirst) {
                    query += " WHERE hora = '" + a.getHora() + "'";
                    isFirst = false;
                } else {
                    query += " AND hora = '" + a.getHora() + "'";
                }
            }

            if (null != a.getSede()) {
                if (isFirst) {
                    query += " WHERE sede = '" + a.getSede() + "'";
                    isFirst = false;
                } else {
                    query += " AND sede = '" + a.getSede() + "'";
                }
            }

            if (null != a.getLugar()) {
                if (isFirst) {
                    query += " WHERE lugar = '" + a.getLugar() + "'";
                    isFirst = false;
                } else {
                    query += " AND lugar = '" + a.getLugar() + "'";
                }
            }

            System.out.println(query);
            st = conexion.createStatement();
            rs = st.executeQuery(query);

            while (rs.next()) {
                aux = new PeriodoInscripcion();
                aux.setId(rs.getInt("id"));
                aux.setFecha(rs.getString("fecha"));
                aux.setHora(rs.getString("hora"));
                aux.setSede(rs.getString("sede"));
                aux.setLugar(rs.getString("lugar"));

                res.add(aux);
            }
        } catch (SQLException se) {
            System.out.println(se.getMessage());
            return new ArrayList<PeriodoInscripcion>();
        }
        return res;
    }

    //Seccion de métodos privados
    /**
     * Metodo para actualizar la clave de un usuario dentro de la base de datos
     * el objeto registro tiene informacion sobre la clave, el privilegio y la
     * fecha de ingreso de un usuario. Retorna un entero que representa cuantas
     * claves fueron actualizada
     *
     * @param registro usuario a modificar
     * @return actualizados cantidad de claves actualizadas
     */
    private int actualizarClave(Registro registro) throws SQLException {
//    conectar();
        String sqlquery = "UPDATE \"PIO\".\"registro\" "
                + "SET clave = '" + registro.getClave()
                + "' , estado = true WHERE registro.cedula = '"
                + registro.getCedula() + "'";
        System.out.println(sqlquery);
        Statement stmt = conexion.createStatement();
        int actualizados = stmt.executeUpdate(sqlquery);
        return actualizados;
    }

    /**
     * Metodo para obtener el rol de un estudiante esta numerado segun la
     * funcion del participante dentro del
     *
     * @param registro usuario para obtener rol
     * @return rol que representa el tipo de estudiante
     */
    private int obtenerRol(Registro registro) throws SQLException, Exception {

//    if (!conectar()) {
//      return -1;
//    }
        String sqlquery = "SELECT rol, estado, clave FROM \"PIO\".\"registro\" WHERE registro.cedula = '"
                + registro.getCedula() + "'";
        System.out.println(sqlquery);
        Statement stmt = conexion.createStatement();
        ResultSet rs = stmt.executeQuery(sqlquery);
        if (!rs.next()) {
            return -1;
        } else {
            int rol = Integer.parseInt(rs.getString("rol"));
            String clave = rs.getString("clave");
            boolean estado = rs.getBoolean("estado");
            if (!estado) {
                actualizarClave(registro);
                return rol;
            }
            if (!clave.equals(registro.getClave())) {
                return -1;
            }
            return rol;
        }
    }

    private String getCurrentTime() {
        // El campo en la base de datos es actualmente VARCHAR(10)
        return (new SimpleDateFormat("dd/MM/yyyy")).format(new Date());
    }

    /**
     * Método que, dado un nombre de un atributo y un patrón que se desea buscar
     * como substring en el atributo, devuelve un strong con la condición que se
     * debe cumplir escrita en el lenguaje de PostgreSQL. La condición no será
     * sensible a mayúsculas.
     *
     * @param attName Nombre del atributo que se desea comparar
     * @param pattern Patrón que se desea encontrar en el atributo
     *
     * @return Un string que contiene la condición que se debe cumplir si el
     * patrón está presente en el string
     */
    private String crearLike(String attName, String pattern) {
        return "lower(" + attName + ") LIKE '%" + pattern.toLowerCase() + "%'";
    }

    /**
     * Método que, dado un usuario, genera la condición que se debe incluir en
     * un SELECT que consulte la tabla usuario para obtener los usuarios con los
     * datos deseados.
     *
     * @param a Objeto Usuario que contiene en sus atributos la consulta
     * @param isFirst Booleano que indica si se está agregando atributos por
     * primera vez al query
     *
     * @return String que representa la condición que se le debe agregar al
     * query
     */
    private String construirCondicionUsuario(Usuario a, boolean isFirst) {
        String query = "";
        for (int i = 0; i < 9; ++i) {
            switch (i) {
                case 0:
                    if (!(null == a.getCedula()
                            || a.getCedula().equals(""))) {
                        if (isFirst) {
                            query += " WHERE cedula = '" + a.getCedula() + "'";
                            isFirst = false;
                        } else {
                            query += " AND cedula = '" + a.getCedula() + "'";
                        }
                    }
                    break;
                case 1:
                    if (!(null == a.getNombres()
                            || a.getNombres().equals(""))) {
                        if (isFirst) {
                            query += " WHERE " + this.crearLike("nombres", a.getNombres());
                            isFirst = false;
                        } else {
                            query += " AND " + this.crearLike("nombres", a.getNombres());
                        }
                    }
                    break;
                case 2:
                    if (!(null == a.getApellidos()
                            || a.getApellidos().equals(""))) {
                        if (isFirst) {
                            query += " WHERE " + this.crearLike("apellidos", a.getApellidos());
                            isFirst = false;
                        } else {
                            query += " AND " + this.crearLike("apellidos", a.getApellidos());
                        }
                    }
                    break;
                case 3:
                    if (!(null == a.getSexo()
                            || a.getSexo().equals(""))) {
                        if (isFirst) {
                            query += " WHERE sexo = '" + a.getSexo() + "'";
                            isFirst = false;
                        } else {
                            query += " AND sexo = '" + a.getSexo() + "'";
                        }
                    }
                    break;
                case 4:
                    if (!(null == a.getCorreo()
                            || a.getCorreo().equals(""))) {
                        if (isFirst) {
                            query += " WHERE correo = '" + a.getCorreo() + "'";
                            isFirst = false;
                        } else {
                            query += " AND correo = '" + a.getCorreo() + "'";
                        }
                    }
                    break;
                case 5:
                    if (!(null == a.getDireccion()
                            || a.getDireccion().equals(""))) {
                        if (isFirst) {
                            query += " WHERE direccion = '" + a.getDireccion() + "'";
                            isFirst = false;
                        } else {
                            query += " AND direccion = '" + a.getDireccion() + "'";
                        }
                    }
                    break;
                case 6:
                    if (!(null == a.getTelefonoCasa()
                            || a.getTelefonoCasa().equals(""))) {
                        if (isFirst) {
                            query += " WHERE telefonoCasa = '" + a.getTelefonoCasa() + "'";
                            isFirst = false;
                        } else {
                            query += " AND telefonoCasa = '" + a.getTelefonoCasa() + "'";
                        }
                    }
                    break;
                case 7:
                    if (!(null == a.getTelefonoCelular()
                            || a.getTelefonoCelular().equals(""))) {
                        if (isFirst) {
                            query += " WHERE telefonoCelular = '" + a.getTelefonoCelular() + "'";
                            isFirst = false;
                        } else {
                            query += " AND telefonoCelular = '" + a.getTelefonoCelular() + "'";
                        }
                    }
                    break;
                case 8:
                    if (!(null == a.getNacionalidad()
                            || a.getNacionalidad().equals(""))) {
                        if (isFirst) {
                            query += " WHERE nacionalidad = '" + a.getNacionalidad() + "'";
                            isFirst = false;
                        } else {
                            query += " AND nacionalidad = '" + a.getNacionalidad() + "'";
                        }
                    }
                    break;
            }
        }
        return query;
    }

    private void setAtts(Usuario usr, ResultSet rs) throws SQLException {
        String cedula = rs.getString("cedula");
        String nombres = rs.getString("nombres");
        String apellidos = rs.getString("apellidos");
        String sexo = rs.getString("sexo");
        String correo = rs.getString("correo");
        String direccion = rs.getString("direccion");
        String fechaNacimiento = rs.getString("fechanacimiento");
        String telefonoCasa = rs.getString("telefonocasa");
        String telefonoCelular = rs.getString("telefonocelular");
        String nacionalidad = rs.getString("nacionalidad");
        usr.setNombres(nombres);
        usr.setApellidos(apellidos);
        usr.setSexo(sexo);
        usr.setCorreo(correo);
        usr.setDireccion(direccion);
        usr.setFechaNacimiento(fechaNacimiento);
        usr.setTelefonoCasa(telefonoCasa);
        usr.setTelefonoCelular(telefonoCelular);
        usr.setNacionalidad(nacionalidad);
        usr.setCedula(cedula);
    }

    /**
     * Retorna un string que contiene la fecha actual en el formato yyyy/MM/dd
     * HH:mm
     *
     * @return String con la fecha actual en formato de la base de datos
     */
    private String obtenerFechaActualDB() {
        GregorianCalendar hoy = new GregorianCalendar();
        return hoy.get(GregorianCalendar.YEAR) + "/"
                + ((hoy.get(GregorianCalendar.MONTH) + 1) < 10 ? "0" + (hoy.get(GregorianCalendar.MONTH) + 1) : (hoy.get(GregorianCalendar.MONTH) + 1)) + "/"
                + (hoy.get(GregorianCalendar.DAY_OF_MONTH) < 10 ? "0" + hoy.get(GregorianCalendar.DAY_OF_MONTH) : hoy.get(GregorianCalendar.DAY_OF_MONTH))
                + " " + (hoy.get(GregorianCalendar.HOUR_OF_DAY) < 10 ? "0" + hoy.get(GregorianCalendar.HOUR_OF_DAY) : hoy.get(GregorianCalendar.HOUR_OF_DAY))
                + ":" + (hoy.get(GregorianCalendar.MINUTE) < 10 ? "0" + hoy.get(GregorianCalendar.MINUTE) : hoy.get(GregorianCalendar.MINUTE));
    }

    /**
     * Retorna una fecha en el formato dd/MM/yyyy a partir de una en formato
     * yyyy/MM/dd
     *
     * @param fechaDB Fecha tomada de la base de datos en formato yyyy/MM/dd
     * HH:mm
     * @return String que contiene la misma fecha que fechaDB pero en formato
     * dd/MM/yyyy
     */
    private String invertirFechaDB(String fechaDB) {
        String[] fecha = fechaDB.split("/");
        return fecha[2].substring(0, 2) + "/" + fecha[1] + "/" + fecha[0];
    }

    /**
     * Consultar el regisro dado un usuario
     *
     * @param u usuario para ser consultado su contrasena o registro
     * @return Un objeto registro con los datos de roles del usuario u
     */
    public Registro consultarRegistro(Usuario u) {
        try {
            Registro r = new Registro();
            String sqlquery = "SELECT registro.* "
                    + "FROM \"PIO\".registro "
                    + "NATURAL JOIN \"PIO\".usuario"
                    + " WHERE cedula = '" + u.getCedula() + "'";
            System.out.println(sqlquery);
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            if (rs.next()) {
                r.setCedula(rs.getString("cedula"));
                r.setClave(rs.getString("clave"));
                System.out.println("Respuesta BD:" + r.getCedula() + r.getClave());
            }
            return r;
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /* Devuelve un switch con la informacion del periodo no deprecado
     * 
     */
    public Switch consultarSwitch() {
        try {
            Switch s = new Switch();
            String sqlquery = "SELECT * FROM \"PIO\".switches";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(sqlquery);
            if (rs.next()) {

                System.out.println("1------------------");
                s.setEntregaResultadosAdmision(rs.getString("entregaResultadosAdmision"));

                System.out.println("2------------------");
                s.setEntregaResultadosPreinscripcion(rs.getString("entregaResultadosPreinscripcion"));

                System.out.println("3-------------------");
                s.setEntregaResultadosPreseleccion(rs.getString("entregaResultadosPreseleccion"));

                System.out.println("4--------------------");
                s.setFechaPruebaAdmision1(rs.getString("fechaPruebaAdmision1"));

                System.out.println("5---------------------");
                s.setFechaPruebaAdmision2(rs.getString("fechaPruebaAdmision2"));

                System.out.println("6---------------------");
                s.setInscripcionEstudiantesB(rs.getBoolean("inscripcionEstudiantes"));
                System.out.println(s.getInscripcionEstudiantes());

                System.out.println("7------------------------");
                s.setPreinscripcionCoodinadoresB(rs.getBoolean("preinscripcionCoordinadores"));
                System.out.println(s.getPreinscripcionCoodinadores());

                System.out.println("8---------------------------");
                s.setPreinscripcionEstudiantesB(rs.getBoolean("preinscripcionEstudiantes"));
                System.out.println(s.getInscripcionEstudiantes());

                System.out.println("9-------------------------");
                s.setPreseleccionCoordinadoresB(rs.getBoolean("preseleccionCoordinadores"));
                System.out.println(s.getPreseleccionCoordinadores());

                System.out.println("10-----------------------");
                s.setPreseleccionEstudiantesB(rs.getBoolean("preseleccionEstudiantes"));
            }
            System.out.print("SALI DEL IF");
            return s;
        } catch (Exception e) {
        }
        return null;
    }

    /* Agregar un switch
     * 
     */
    public static Boolean agregarSwitch(Switch s) {
        if (s.valido()) {
            try {
                String sqlquery1 = "DELETE FROM \"PIO\".switch ";
                String sqlquery2 = "INSERT INTO \"PIO\".switch (" + s.toStringAtts() + ") VALUES (" + s.toStringValues() + ")";
                Statement stmt = conexion.createStatement();
                Integer eliminado = stmt.executeUpdate(sqlquery1);
                if (eliminado > 0) {
                    System.out.println("Se elimino el periodo anterior");
                }
                Statement stmt2 = conexion.createStatement();
                Integer agregado = stmt.executeUpdate(sqlquery2);
                return agregado > 0;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return false;
        }
        return false;
    }

    public Aspirante consultarAspirante(Aspirante aspi) {

        try {
            String sqlquery = "SELECT * "
                    + "FROM \"PIO\".aspirante "
                    + "NATURAL JOIN \"PIO\".usuario "
                    + "WHERE cedula = '" + aspi.getCedula() + "'";
            Statement stmt = conexion.createStatement();
            System.out.println(sqlquery);
            ResultSet rs = stmt.executeQuery(sqlquery);
            if (rs.next()) {
                this.setAtts(aspi, rs);
                aspi.setPromedio(rs.getDouble("promedio"));
                aspi.setDatosCompletos((rs.getInt("datoscompletos") == 0 ? false : true));
                return aspi;
            } else {
                System.out.println("No hubo consulta de aspirante");
                return null;
            }
        } catch (SQLException ex) {
            Logger.getLogger(DataBaseManager.class.getName()).log(Level.SEVERE, null, ex);
        }

        return null;
    }

    /* Consultar Una Planilla de Inscripcion
     * 
     */
    public Inscripcion consultarPlanillaInscripcion(Preinscrito p) {
        Inscripcion i = new Inscripcion();
        i.setCedula(p.getCedula());
        try {
            String query = "SELECT * FROM \"PIO\".planillainscripcion WHERE cedula ='" + i.getCedula()+"'";
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(query);
            if (rs.next()) {
                i.setApellidos(rs.getString("apellidos"));
                i.setCedulaRepresentante(rs.getString("cedularepresentante"));
                i.setCorreo(rs.getString("correo"));
                i.setCualenfermedad(rs.getString("direccion"));
                i.setDireccion(rs.getString("direccion"));
                i.setDireccionRepresentante(rs.getString("direccionrepresentante"));
                i.setDireccionTrabajoRepresentante(rs.getString("direcciontrabajorepresentante"));
                i.setEdad(String.valueOf(rs.getInt("edad")));
                i.setEnfermedad(rs.getString("enfermedad"));
                i.setFechaNacimiento(rs.getString("fechanacimiento"));
                i.setIndicaciones(rs.getString("indicaciones"));
                i.setLugarTrabajoRepresentante("lugartrabajorepresentante");
                i.setNombreRepresentante("nombrerepresentante");
                i.setNombres(rs.getString("nombres"));
                i.setSexo(rs.getString("sexo"));
                i.setTelefono1(rs.getString("telefono1"));
                i.setTelefono1Representante(rs.getString("telefono1representante"));
                i.setTelefono2(rs.getString("telefono2"));
                i.setTelefono2Representante(rs.getString("telefono2representante"));
                i.setTelefonoOficinaRepresentante(rs.getString("telefonooficinarepresentante"));
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        return i;
    }

    /*
     * Consultar Todas las Planillas de Inscripcion
     */
    public ArrayList<Inscripcion> consultarPlanillaInscripcion() {
        ArrayList<Inscripcion> ar = new ArrayList<Inscripcion>();
        try {
            String query = "SELECT * FROM \"PIO\".planillainscripcion ";
            System.out.println(query);
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(query);
            while (rs.next()) {
                Inscripcion i = new Inscripcion();
                i.setApellidos(rs.getString("apellidos"));
                i.setNombres(rs.getString("nombres"));
                i.setCedula(rs.getString("cedula"));
                i.setEdad(rs.getString("edad"));
                i.setSexo(rs.getString("sexo"));
                i.setFechaNacimiento(rs.getString("fechanacimiento"));
                i.setCorreo(rs.getString("correo"));
                i.setDireccion(rs.getString("direccion"));
                i.setTelefono1(rs.getString("telefono1"));
                i.setTelefono2(rs.getString("telefono2"));
                i.setNombreRepresentante(rs.getString("nombrerepresentante"));
                i.setCedulaRepresentante(rs.getString("cedularepresentante"));
                i.setTelefono1Representante(rs.getString("telefono1representante"));
                i.setTelefono2Representante(rs.getString("telefono2representante"));
                i.setDireccionRepresentante(rs.getString("direccionrepresentante"));
                i.setLugarTrabajoRepresentante(rs.getString("lugartrabajorepresentante"));
                i.setDireccionTrabajoRepresentante(rs.getString("direcciontrabajorepresentante"));
                i.setTelefonoOficinaRepresentante(rs.getString("telefonooficinarepresentante"));
                i.setEnfermedad(rs.getString("enfermedad"));
                i.setCualenfermedad(rs.getString("cualenfermedad"));
                i.setIndicaciones(rs.getString("indicaciones"));
                ar.add(i);
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        return ar;
    }

    /* Agregar una Planillla de Inscripcion
     * 
     */
    public void agregarPlanillaInscripcion(Inscripcion i) {
        try {

            String query2 = "DELETE FROM \"PIO\".planillainscripcion WHERE cedula =  '" + i.getCedula() + "'";
            System.out.println(query2);
            Statement stmt1 = conexion.createStatement();
            int eliminados = stmt1.executeUpdate(query2);

            String query = "INSERT INTO \"PIO\".planillainscripcion("
                    + "cedula, apellidos, cedularepresentante , correo , cualenfermedad , "
                    + " direccion,  direccionrepresentante  , direcciontrabajorepresentante , edad ,"
                    + " enfermedad , fechanacimiento ,indicaciones  , lugartrabajorepresentante , "
                    + " nombrerepresentante, nombres , sexo , telefono1 , telefono1representante , telefono2 ,"
                    + "telefono2representante , telefonooficinarepresentante"
                    + ") " + "VALUES ('"
                    + i.getCedula() + "','" + i.getApellidos() + "','" + i.getCedulaRepresentante() + "','" + i.getCorreo() + "','"
                    + i.getCualenfermedad() + "','" + i.getDireccion() + "','" + i.getDireccionRepresentante() + "','"
                    + i.getDireccionTrabajoRepresentante() + "','" + i.getEdad() + "','" + i.getEnfermedad() + "','"
                    + i.getFechaNacimiento() + "','" + i.getIndicaciones() + "','" + i.getLugarTrabajoRepresentante() + "','"
                    + i.getNombreRepresentante() + "','" + i.getNombres() + "','"
                    + i.getSexo() + "','" + i.getTelefono1() + "','" + i.getTelefono1Representante() + "','" + i.getTelefono2()
                    + "','" + i.getTelefono2Representante() + "','" + i.getTelefonoOficinaRepresentante() + "')";
            Statement stmt = conexion.createStatement();
            System.out.println(query);
            int agregados = stmt.executeUpdate(query);
            System.out.print("UnoaUno .... Agregados ===" + agregados + "Eliminados ====" + eliminados);
        } catch (SQLException ex) {
            ex.printStackTrace();
            System.out.print("EN la excepcion");
        }
    }

    public boolean preinscritoAceptado(Preinscrito pre) {
        ArrayList<RegistroPrueba> rp = this.consultarInscritos();
        for (RegistroPrueba registroPrueba : rp) {
            if (registroPrueba.getCedula().equalsIgnoreCase(pre.getCedula())
                    && registroPrueba.getIsInscrito()) {
                return true;
            }
        }
        return false;
    }

    public void eliminarRegistroInscripcion() {
        try {
            String query = "DELETE FROM \"PIO\".registroinscripcion";
            Statement stmt = conexion.createStatement();
            int eliminados = stmt.executeUpdate(query);
            System.out.println(query + eliminados);
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
    }

    public void agregarRegistrosPruebas(List<RegistroPrueba> pruebas, String corte) {
        try {
            String query[] = new String[pruebas.size()];
            int index = 0;
            PreparedStatement insert = conexion.prepareStatement("INSERT  INTO  \"PIO\".registroinscripcion"
                    + " values (?,?,?,?,?,?,?)");
            Statement stmt = conexion.createStatement();
            for (RegistroPrueba registroPrueba : pruebas) {
                insert.setString(1, registroPrueba.getCedula());
                insert.setString(2, registroPrueba.getRespuestaPrueba());
                insert.setString(3, registroPrueba.getNotaRaven());
                insert.setString(4, registroPrueba.getNotaVerbal());
                insert.setString(5, registroPrueba.getNotaMatematica());
                insert.setString(6, registroPrueba.getNotaTotal());
                if (Double.parseDouble(registroPrueba.getNotaTotal()) >= Double.parseDouble(corte)) {
                    insert.setString(7, "Si");
                } else {
                    insert.setString(7, "No");
                }
                insert.addBatch();
                insert.executeBatch();
            }
            stmt.executeBatch();
            stmt.clearBatch();
            stmt.close();
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
    }

    public ArrayList<RegistroPrueba> consultarInscritos() {
        ArrayList<RegistroPrueba> ar = new ArrayList<RegistroPrueba>();
        try {
            String query = "SELECT * FROM \"PIO\".registroinscripcion ";
            System.out.println(query);
            Statement stmt = conexion.createStatement();
            ResultSet rs = stmt.executeQuery(query);
            while (rs.next()) {
                RegistroPrueba rp = new RegistroPrueba();
                rp.setCedula(rs.getString("cedula"));
                rp.setNotaMatematica(rs.getString("notamatematica"));
                rp.setNotaRaven(rs.getString("notaraven"));
                rp.setNotaVerbal(rs.getString("notaverbal"));
                rp.setNotaTotal(rs.getString("notatotal"));
                rp.setRespuestaPrueba(rs.getString("respuestaprueba"));
                String i = rs.getString("admitido");
                rp.setIsInscrito((i.equalsIgnoreCase("si") ? new Boolean(true) : new Boolean(false) ));
                ar.add(rp);
            }
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        return ar;
    }
}